UiPath-SAIv1 UiPath Certified Professional Specialized AI Professional v1.0 Questions and Answers

In UiPath's Taxonomy Manager, the "Possible values" rule should be used when a text field can have one of several predefined values. This ensures that the extracted data is validated against a list of acceptable values, helping to maintain consistency and accuracy during the extraction process. It is particularly useful for fields such as status indicators or categorical fields where only a limited set of options is valid.

(Source: UiPath Taxonomy Manager documentation)

The Sentiment Analysis out-of-the-box model in UiPath is used to interpret and classify the emotional tone within text data. It is particularly useful for analyzing product reviews, customer feedback, social media posts, and emails to understand customer sentiment and emotional responses, helping businesses make informed decisions based on these insights.(Source: UiPath Sentiment Analysis model documentation

The "Wait for Classification Validation Task and Resume" activity in UiPath's Document Understanding Framework is primarily used to halt or suspend the workflow until a specified document classification validation task is completed by a human. This activity is part of the broader workflow to ensure that when automatic classification of documents cannot be confidently achieved, a human-in-the-loop (HITL) approach is followed to validate or correct classifications. Once the validation is performed in UiPath's Action Center by a human, the workflow is resumed, ensuring the proper handling of documents that require review and correction.

This is aligned with the design of the Action Center, which is integrated into UiPath's Document Understanding Framework. When dealing with document classification or extraction confidence issues, manual human validation tasks are often required, which is what this activity manages. It facilitates human oversight, preventing the automation from proceeding with potentially incorrect classifications.

Reference from UiPath documentation:

UiPath Action Center explains how humans are involved in validation tasks to handle cases where classification or extraction needs manual review.

Wait for Task and Resume Activity in UiPath Documentation explains how it waits for a task (such as document validation) to be completed in the Action Center before resuming the workflow.

For more details, you can consult the official UiPath documents:

UiPath Document Understanding Framework

Wait for Classification Validation Task and Resume

This functionality ensures that incorrect data processing due to automation can be caught and rectified by a human, improving accuracy in document handling workflows.

UiPath Communications Mining uses Natural Language Processing (NLP) to analyze and process unstructured communication data such as emails, chat logs, and other textual inputs. This enables automation to identify actionable insights from large volumes of communication data.

After the data is extracted using the UiPath Document Understanding framework, it is crucial to handle the data securely and efficiently for further use in other processes or storage. Serialization is often used to convert the extracted data into a format suitable for storage or transmission. By serializing the data, it can be stored in storage buckets (such as cloud storage or a database) and accessed later as needed for subsequent processing. This approach ensures that data is preserved, secure, and available for other workflows or automations.

(Source: UiPath Document Understanding Documentation).

According to the UiPath documentation, the ‘Teach’ training mode is used to improve the model’s predictions for a specific label by pinning it to more communications that match the label’s criteria. This helps the model learn from more examples and increase its confidence and accuracy. The ‘Teach’ mode also allows you to unpin the label from communications that do not match it, which helps the model avoid false positives. The other training modes are not as effective for this purpose, as they either focus on different aspects of the model performance or do not provide enough feedback to the model.

References:

Model training and labelling best practice

Overview of the model training process

Model Training FAQs

Recall is a metric that measures the proportion of all possible true positives that the model was able to identify for a given concept1. A true positive is a case where the model correctly predicts the presence of a concept in the data. Recall is calculated as the ratio of true positives to the sum of true positives and false negatives, where a false negative is a case where the model fails to predict the presence of a concept in the data. Recall can be interpreted as the sensitivity or completeness of the model for a given concept2. For example, if there are 100 verbatims that should have been labelled as ‘Request for information’, and the model detects 80 of them, then the recall for this concept is 80% (80 / (80 + 20)). A high recall means that the model is good at finding all the relevant cases for a concept, while a low recall means that the model misses many of them.

References: 1: Recall 2: Precision and Recall

According to the UiPath documentation, Page Units are the measure used to license Document Understanding products. Page Units are charged based on the number of pages processed by the Document Understanding models, such as extractors, OCR engines, and classifiers. Therefore, applying OCR on a 10-page document consumes Page Units, while the other options do not. The creation of a Document Validation Action in Action Center does not consume any Page Units, as it is a human-in-the-loop activity. Using ML Classifier on a 21-page document does not consume Page Units, as it is a free model. Using Intelligent Form Extractor on a 5-page document with 0 successful extractions does not consume Page Units, as the extractor only charges for successful extractions.

References:

AI Center - AI Units

Document Understanding - Metering & Charging Logic

In UiPath AI Center, ML Skills can be managed in various ways, allowing users to customize and control how these skills are deployed and used. The management options include:

Creating a new ML skill.

Stopping a deployed skill.

Redeploying an ML skill.

Updating to a new package version.

Rolling back to a previous version if needed.

Modifying GPU usage.

Modifying the use of AI units.

Making the skill public or private.

Deleting an ML skill when no longer needed.

This provides flexibility for both managing the ML infrastructure and optimizing resources in real-time.

For more details, refer to:

UiPath AI Center Documentation: Managing ML Skills

ML Skill Management Options: Managing Machine Learning Skills in AI Center

In UiPath's Document Understanding Framework, UiPath Document OCR is recommended as the initial OCR engine for processing documents. This OCR option is optimized for extracting text from a wide variety of document types and provides good accuracy with structured, semi-structured, and unstructured documents. It is designed to work seamlessly within the UiPath Document Understanding process and is highly compatible with other UiPath activities and models, making it a preferred choice for starting document processing in most projects.

For more details, refer to:

UiPath Document Understanding Framework: UiPath OCR Engines

UiPath Document OCR: UiPath OCR Guide

According to the UiPath documentation, the recommended number of documents per vendor to train the initial dataset is 10. This means that for each vendor that provides a specific type of document, such as invoices or receipts, you should have at least 10 samples of their documents in your training dataset. This helps to ensure that the dataset is balanced and representative of the real-world data, and that the machine learning model can learn from the variations and features of each vendor’s documents. Having too few documents per vendor can lead to poor model performance and accuracy, while having too many documents from a single vendor can cause overfitting and bias1.

References: 1: Document Understanding - Training High Performing Models

When setting up a classification label in UiPath's Out Of the Box (OOB) labeling templates, you need to provide several key details: the name of the label, the classification type (which defines the kind of label), the input to be labeled, the attribute name that describes the label's context, a shortcut for quick access, and a color for visual distinction. These fields ensure the label is fully defined and easy to manage in workflows.

(Source: UiPath Document Understanding documentation)

To iterate through all Microsoft Word documents in a local folder using the For Each File in Folder activity, you should use the filter option "*.doc*". This filter utilizes the asterisk (*) wildcard to match any number of characters, effectively capturing both .doc and .docx file extensions.

UiPath Documentation

In the Filter by field of the activity, entering "*.doc*" ensures that the iteration includes all files with names ending in .doc or .docx, which are standard extensions for Microsoft Word documents.

Other options are incorrect because:

B. Microsoft Word: This is not a valid filter pattern.

*C. " doc"**: This pattern looks for files with names ending in " doc" and does not account for file extensions.

*D. " doc, *docx"**: This is not a valid filter pattern; multiple patterns should be separated by semicolons (e.g., "*.doc;*.docx").

Therefore, the correct filter to use is "*.doc*".

to load a taxonomy from a given non-default location text file into a variable, the order of steps should be as follows:

Create a new variable of type 'DocumentTaxonomy' called 'documentTaxonomy', then create a new string variable called 'taxonomyPath'.

This step involves setting up the necessary variables that will be used in the process. The 'documentTaxonomy' variable will hold the deserialized taxonomy object, and 'taxonomyPath' will store the path to the taxonomy file.

Using an Assign activity, assign the given non-default taxonomy text file path to the most recent variable created.

Here you will assign the path of the taxonomy file to the 'taxonomyPath' variable.

Use the Read Text File activity on the 'taxonomyPath' variable created. Next, create a new variable 'taxonomyText', then save the output of the Read Text File activity to 'taxonomyText'.

This step is where you read the contents of the taxonomy file using the 'Read Text File' activity. The contents are stored in the 'taxonomyText' variable.

Inside the last Assign activity 'Value to Save' property add the following expression: "Newtonsoft.Json.JsonConvert.DeserializeObject(Of DocumentTaxonomy)(taxonomyText)" where 'taxonomyText' is the text read from the file and 'documentTaxonomy' (the most recent variable created) is the variable you created.

In this final step, you will deserialize the JSON content from the 'taxonomyText' into a 'DocumentTaxonomy' object using the 'JsonConvert.DeserializeObject' method and assign it to the 'documentTaxonomy' variable.

Following these steps in this order will load the taxonomy from a text file into the 'documentTaxonomy' variable in UiPath.

In UiPath Communications Mining, high coverage ensures that a larger proportion of communications is classified with meaningful labels, meaning fewer communications are sent for manual review and more processes are captured for automation. This leads to more effective automation, reducing the need for human intervention and ensuring that the automation use case is fully realized.

For more details, refer to:

UiPath Communications Mining Performance Metrics: Coverage and Automation

UiPath offers several pre-trained out-of-the-box models, and Invoices is one of the most commonly supported document types. This model is optimized to extract relevant fields such as invoice numbers, dates, amounts, and more from structured invoices. Other common out-of-the-box models include receipts and purchase orders.

 Adding missed labels helps improve the label precision and recall in UiPath Communications Mining. Precision is the percentage of correctly labeled verbatims out of all the verbatims that have the label applied, while recall is the percentage of correctly labeled verbatims out of all the verbatims that should have the label applied. By adding missed labels, you are increasing the recall of the label, as you are reducing the number of false negatives (verbatims that should have the label but do not). This also improves the precision of the label, as you are reducing the noise in the data and making the label more informative and consistent. Adding missed labels is one of the recommended actions that the platform suggests to improve the model rating and performance of the labels.

References: Communications Mining - Training using ‘Check label’ and ‘Missed label’, Communications Mining - Model Rating

In UiPath, the Verbose log level offers the most detailed information about the execution of activities. It logs every possible detail about the automation operations, including variable changes, function calls, and external responses. This level is particularly useful for in-depth debugging and analysis.

UiPath Documentation

The hierarchy of log levels in ascending order of priority is as follows:

Off: No logs are stored.

Verbose: Logs all details about automation operations.

Trace: Logs finer-grained informational events than the Debug level.

Information: Logs informational messages that highlight the progress of the application.

Warning: Logs potentially harmful situations.

Error: Logs error events that might still allow the application to continue running.

Fatal: Logs very severe error events that will presumably lead the application to abort.

Therefore, setting the log level to Verbose ensures that all possible details about the execution are captured, aiding in thorough diagnostics.

 The ML Classifier is a document classifier that uses a machine learning model deployed as an ML Skill in AI Center to perform document classification tasks. The ML Classifier can work by default with Invoices, Purchase Orders, Receipts, and Utility Bills, or with custom document types that are trained using the Data Manager and the Machine Learning Classifier Trainer12.

According to the best practice, the ML Classifier is the only recommended classifier to be used when the custom document types are very similar and file splitting is not necessary. This is because the ML Classifier can handle complex and ambiguous cases where the document types are hard to distinguish by rules or keywords, and can also learn from feedback and improve over time. File splitting is not necessary when the documents are single-page or have a consistent number of pages per document type3.

The other options are not correct because they are scenarios where other classifiers, such as the Keyword Based Classifier or the Intelligent Keyword Classifier, can be used in combination with the ML Classifier or instead of it. These classifiers are based on rules or keywords that can identify the document types based on their content or metadata, and can also perform file splitting if the documents are multi-page or have a variable number of pages per document type3.

References: 1: Machine Learning Classifier - UiPath Activities 2: Machine Learning Classifier Trainer - UiPath Document Understanding 3: Document Classification - UiPath Document Understanding

According to the UiPath documentation, the Taxonomy component is used in the Document Understanding Template to define the document types and the fields that are targeted for data extraction for each document type. The Taxonomy component is the metadata that the Document Understanding framework considers in each of its steps, such as document classification and data extraction. The Taxonomy component allows you to create, edit, import, or export the taxonomy of your project, which is a collection of document types and fields that suit your specific objectives. The Taxonomy component also allows you to configure the field types, details, and validations, as well as the supported languages and categories for your documents.

References:

Document Understanding - Taxonomy

Document Understanding - Taxonomy Overview

Document Understanding - Create and Configure Fields

 A label taxonomy is a hierarchical structure of concepts that you want to capture from your communications data, such as emails, chats, or calls. Each label represents a specific concept that serves a business purpose and is aligned to your objectives. A label taxonomy can have multiple levels of hierarchy, where each child label is a subset of its parent label. For example, a parent label could be “Product Feedback” and a child label could be “Product Feature Request” or “Product Bug Report”. A label taxonomy is used to train a machine learning model that can automatically classify your communications data according to the labels you defined1.

One of the best practices for designing a label taxonomy is to ensure that each label is clearly identifiable from the text of the individual verbatim (not thread) to which it will be applied. A verbatim is a single unit of communication, such as an email message, a chat message, or a call transcript segment. A thread is a collection of related verbatims, such as an email conversation, a chat session, or a call recording. When you train your model, you will apply labels to verbatims, not threads, so it is important that each label can be recognized from the verbatim text alone, without relying on the context of the thread. This will help the model to learn the patterns and features of each label and to generalize to new data. It will also help you to maintain consistency and accuracy when labelling your data2.

References: 1: Communications Mining - Taxonomies 2: Communications Mining - Label hierarchy and best practice

 According to the UiPath Document Understanding Process template, the best way to test the code in a development or testing environment is to create test data based on the use case developed, and use it to test both the existing and the new tests. The test data should include different document types, formats, and scenarios that reflect the real-world data that the process will handle in production. The existing tests are provided by the template and cover the main functionalities and components of the Document Understanding Process, such as digitization, classification, data extraction, validation, and export. The new tests are created by the developer to test the customizations and integrations that are specific to the use case, such as custom extractors, classifiers, or data consumption methods. The test data and the test cases should be updated and maintained throughout the development lifecycle to ensure the quality and reliability of the code.

References:

Document Understanding Process: Studio Template

Document Understanding Process: User Guide

 According to the UiPath documentation, the RegEx Extractor is a data extraction method that uses regular expressions to define and capture data from documents1. The RegEx Extractor does not consume any page units, which are the units of measurement for the consumption of Document Understanding services2. Therefore, the page unit cost per extracted page for the RegEx Extractor is 0.

References:

1: RegEx Extractor 2: Document Understanding - Metering & Charging Logic

The main purpose of the Document Understanding Process template in UiPath Studio is to provide users with a ready-to-use document processing framework. It is designed to simplify the development of document understanding automations by offering out-of-the-box features like logging, exception handling, and retry mechanisms. This template allows developers to quickly start working on both simple demos and large-scale document processing projects without needing to build everything from scratch. It is equipped with key components such as classifiers and extractors to streamline document classification and data extraction workflows

 Entity predictions refer to the process of identifying and highlighting a specific span of text within a communication that represents a value for a predefined entity type. For example, an entity type could be “Organization” and an entity value could be “UiPath”. Entity predictions are made by the platform based on the training data and the rules defined for each entity type. Users can review, accept, reject, or modify the entity predictions using the Classification Station interface12.

References: Communications Mining - Reviewing and applying entities, Communications Mining - Predictions - UiPath Documentation Portal.

In UiPath Communications Mining, pinning a model ensures that the predictions shown in the Explore tab are generated from that specific model version. This feature allows users to control which version of the model is actively making predictions, particularly during evaluation or comparison stages. By pinning a model, the user ensures that the UI reflects the predictions from the selected version, helping maintain consistency when analyzing results or making changes.

For more details, refer to:

UiPath Communications Mining: Model Management and Pinning

UiPath AI Center Documentation: Managing Model Versions

The Document Understanding Process is a fully functional UiPath Studio project template based on a document processing flowchart. It supports both attended and unattended robots with human-in-the-loop validation via Action Center. The process uses queues to store and process the input files, one file per queue item. However, the Auto Retry Functionality should be disabled on queues, because it can interfere with the human validation step and cause errors or duplicates. The process handles the retry mechanisms internally, using the Try/Catch and Error management features.

References:

Document Understanding Process: Studio Template

Document Understanding Process - New Studio Template

When creating the scope for automation during the Process Design phase, several critical factors need to be taken into account to ensure a successful automation project. These include:

Document Types: The types of documents that will be processed (invoices, receipts, etc.).

Taxonomy: The classification and structuring of the data that will be extracted.

Templates: The standardized formats for documents, which can improve extraction accuracy.

Languages: The different languages in which documents are written, affecting the need for multilingual support.

Scans/Digital Docs: Whether the documents are scanned or born-digital, impacting the accuracy of OCR.

Success Criteria: Clear metrics that define the success of the automation (such as accuracy or processing time).

Technical Criteria: Requirements related to the infrastructure, integration, and tools being used (OCR engines, ML models, etc.).

These elements are crucial in defining the technical and functional requirements for automating document processing tasks effectively, ensuring that the scope covers all necessary considerations.

For more details, refer to:

UiPath Process Design Best Practices: Process Design Considerations

UiPath Document Understanding Framework: Scope Definition in Document Understanding

The Solution Architect is responsible for devising a strategy to prioritize processes during the Business Case and Technical Validation phase. Their role involves assessing technical feasibility, scalability, and business value to determine process prioritization.

In UiPath Communications Mining, the shading of label predictions in the Explore section indicates confidence levels. Darker shading represents a higher confidence score, meaning the model is more certain of the prediction made for that particular label​

Document Understanding documentation, when using the "Export Now" tab in the Export Files dialog box within the Document Manager, the available options include:

Download to Excel – This allows downloading the dataset locally in an Excel format.

Export to AI Center – This exports the data directly to the AI Center for use in model training or evaluation.

Export All – This option exports all documents regardless of labeling or filtering status.

These features are designed to facilitate exporting labeled data for further processing in AI Center, or locally for offline analysis

In UiPath, the Data Scientist role is primarily responsible for creating, training, and uploading machine learning models to AI Center. While RPA developers might integrate these models into workflows, it is the Data Scientist who builds and fine-tunes models, ensuring their accuracy and relevance for various use cases.

To build custom models supported by AI Center, you can use a Python IDE or an AutoML platform of your choice. A Python IDE is a software application that provides tools and features for writing, editing, debugging, and running Python code. An AutoML platform is a service that automates the process of building and deploying machine learning models, such as data preprocessing, feature engineering, model selection, hyperparameter tuning, and model evaluation. Some examples of Python IDEs are PyCharm, Visual Studio Code, and Jupyter Notebook. Some examples of AutoML platforms are Google Cloud AutoML, Microsoft Azure Machine Learning, and DataRobot.

To use a Python IDE, you need to install the required Python packages and dependencies, write the code for your model, and test it locally. Then, you need to package your model as a zip file that follows the AI Center ML Package structure and requirements. You can then upload the zip file to AI Center and create an ML Skill to deploy and consume your model.

To use an AutoML platform, you need to sign up for the service, upload your data, configure your model settings, and train your model. Then, you need to export your model as a zip file that follows the AI Center ML Package structure and requirements. You can then upload the zip file to AI Center and create an ML Skill to deploy and consume your model.

References: AI Center - Building ML Packages, AI Center - ML Package Structure, AI Center - Creating ML Skills

The Mean Average Precision (MAP) is the primary metric used in UiPath Communications Mining to assess the performance of classification models, specifically for the "All Labels" factor. MAP evaluates how well the model predicts labels by considering both the precision and recall of the predictions. This metric is commonly used in information retrieval systems to provide an overall measure of accuracy across all labels in the dataset.

(Source: UiPath Communications Mining documentation)

The Label Trends table in UiPath Communications Mining shows the trend of the top 10 highest volume labels over the selected time period, as well as their percentage change and rank change compared to the previous period1. The table allows users to quickly identify which labels are increasing or decreasing in volume, and by how much, over time. The table also shows the net sentiment score for each label, which is calculated as the difference between the positive and negative sentiment probabilities for each verbatim2. The table can be filtered by data type, source, date range, and label category. Users can also sort the table by label name, volume, percentage change, rank change, or net sentiment1.

References: 1: Trends 2: Sentiment Analysis

Unattended automation is ideal for tasks that can run independently without human intervention, such as scheduled activities during off-hours. Running reports and emailing stakeholders overnight is a perfect use case for unattended bots, which can execute the process autonomously.

The DocumentUnderstanding ML package is a generic, retrainable model designed to handle various document types that are not covered by out-of-the-box models. It allows for the extraction of data from structured and semi-structured documents by building a model from scratch through training. This package is highly flexible and can be tailored to fit different document formats, making it ideal when specific document types are not pre-configured in UiPath’s out-of-the-box offerings.(Source: UiPath Documentation on ML Packages

In UiPath:

Variables are scoped to a specific workflow or sequence and are used to store data for operations within that scope.

Arguments, on the other hand, are used to pass data between workflows, allowing information to flow in or out of invoked workflows.

Export the package from AI Center. This is the first step where you prepare the package to be moved.

On the ML Packages page, click the Import ML Package button. This step is where you start the process of importing the package you've exported.

On the Upload package field, add the zip file downloaded using the Downloading ML Packages procedure. After starting the import process, you will upload the actual package.

Click Create. This is the final step where you finalize the uploading process of your ML package.

Please proceed with these steps in the UiPath AI Center to upload your exported package correctly.

When creating an AI Center project in UiPath, the fields available to input are the project's name and description. These fields allow you to clearly label and describe the purpose of the AI project within the UiPath platform. Permissions and labels can be managed separately after the project is created​

Model-based data extraction, often involving machine learning models, is particularly effective for handling complex data structures such as variable-length data or data that spans multiple pages. This approach adapts better to varying formats and can extract information more accurately in such scenarios compared to rule-based or manual methods.

UiPath AI Center offers three primary package types: pre-trained, custom training, and fine-tunable models. These are essential for various use cases, from leveraging existing models to training custom ones based on specific data

In the 2023.10 release of UiPath, a significant new feature is the introduction of generative capabilities for classifying various document types. This update allows for more advanced handling of unstructured data by leveraging AI to automatically generate classifications, even for document types that the model hasn't encountered before. This feature enhances the flexibility and power of Document Understanding, enabling organizations to handle a wider variety of documents without needing extensive manual setup for each new type.

(Source: UiPath 2023.10 Release Notes)

When migrating a schema from Document Manager to a Modern Project, UiPath will override any existing schema associated with the document type if you attempt to import a new schema. This behavior is confirmed in UiPath's handling of document types and schema imports, where the new schema will replace the old one, ensuring that the latest version is applied to the project. This helps maintain consistency in schema configurations during migrations, especially when schemas are updated or need to be standardized

To configure the Validation Station as an attended activity in UiPath, the minimum required inputs include the Taxonomy, which defines the structure and fields for data extraction, the Document Path, the Document Object Model (DOM), the Document Text obtained during digitization, and the Automatic Extraction Results, which are the results from automatic data extraction activities that need validation. These inputs allow the Validation Station to properly display and validate extracted data​

The Classify Document Scope activity in UiPath is used to classify documents supported by the Document Understanding framework. It primarily works with file formats like PDF, JPG, PNG, and other image-based formats but does not process raw or non-standard file types like .raw.

The Document Understanding Process uses two types of synchronization mechanisms to prevent multiple robots from writing in a file at the same time: file locks and queues. File locks are used to ensure that only one robot can access a file at a time, while queues are used to store the information extracted from the documents and to avoid data loss or duplication. The process uses the following activities to implement these mechanisms:

File Lock Scope: This activity creates a lock on a file or folder and executes a set of activities within it. The lock is released when the scope ends or when an exception occurs. This activity ensures that only one robot can read or write a file or folder at a time, and prevents other robots from accessing it until the lock is released.

Add Queue Item: This activity adds an item to a queue in Orchestrator, along with some relevant information, such as a reference, a priority, or a deadline. The item can be a JSON object, a string, or any serializable .NET type. This activity ensures that the information extracted from the documents is stored in a queue and can be retrieved by another robot or process later.

Get Queue Items: This activity retrieves a collection of items from a queue in Orchestrator, based on some filters, such as status, reference, or creation time. The items can be processed by the robot or passed to another activity, such as Update Queue Item or Delete Queue Item. This activity ensures that the information stored in the queue can be accessed and manipulated by the robot or process.

References: Document Understanding Process: Studio Template, File Lock Scope, Add Queue Item, [Get Queue Items]