Supervised learning is one of the most popular and widely used machine learning approaches. It involves providing the algorithm with labeled input/output pairs, which serve as examples of the desired behavior or outcome. The algorithm then learns a function that can generalize from these examples and make predictions for new, unseen data. Supervised learning can be used for tasks such as classification, regression, and anomaly detection. Some common supervised learning algorithms are linear regression, logistic regression, decision trees, support vector machines, and neural networks.

References:

UiPath AI Fabric - Machine Learning Concepts

UiPath Document Understanding - Machine Learning Models

UiPath Communications Mining - Overview

 Document Understanding is a tool that helps you create and manage documents for your automation scenarios in the UiPath ecosystem. It allows you to process and extract data from multiple document types in an open, extensible, and versatile environment. The framework consists of components such as Taxonomy, Digitization, Data Extraction, Data Extraction Validation, Data Extraction Training, and Data Consumption, and enables you to customize and train your own algorithms12.

References: Intelligent Document Processing - Document Understanding | UiPath, Document Understanding - Introduction - UiPath Documentation Portal

The Document Understanding Process template is a fully functional UiPath Studio project template based on a document processing flowchart. It provides logging, exception handling, retry mechanisms, and all the methods that should be used in a Document Understanding workflow, out of the box. The template has an architecture decoupled from other connected automations and supports both attended and unattended processes with human-in-the-loop validation via Action Center. The template consists of the following components1:

Load Taxonomy: This component loads the taxonomy file that defines the document types and fields to be extracted. The taxonomy file can be created using the Taxonomy Manager in Studio or the Data Manager web application.

Digitization: This component converts the input document into a digital format that can be processed by the subsequent components. It uses the Digitize Document activity to perform OCR (optical character recognition) on the document and obtain a Document Object Model (DOM).

Classification: This component determines the document type of the input document using the Classify Document Scope activity. It can use either a Keyword Based Classifier or a Machine Learning Classifier, depending on the configuration. The classification result is stored in a ClassificationResult variable.

Data Extraction: This component extracts the relevant data from the input document using the Data Extraction Scope activity. It can use different extractors for different document types, such as the Form Extractor, the Machine Learning Extractor, the Regex Based Extractor, or the Intelligent Form Extractor. The extraction result is stored in an ExtractionResult variable.

Data Validation: This component allows human validation and correction of the extracted data using the Present Validation Station activity. It opens the Validation Station window where the user can review and edit the extracted data, as well as provide feedback for retraining the classifiers and extractors. The validated data is stored in a DocumentValidationResult variable.

Export: This component exports the validated data to a desired output, such as an Excel file, a database, or a downstream process. It uses the Export Extraction Results activity to convert the DocumentValidationResult variable into a DataTable variable, which can then be manipulated or written using other activities.

References: Document Understanding Process: Studio Template, Document Understanding Process - New Studio Template, Document Understanding Process Template in UiPath Studio

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)

According to the UiPath documentation, the field name for a column field in Document Manager does not accept uppercase letters. It can only contain lowercase letters, numbers, underscore _ and dash -12. Therefore, the only option that meets these criteria is D. First_name123. The other options are invalid because they either contain uppercase letters, spaces, or @ symbols, which are not allowed.

References: 1: Document Understanding - Create and Configure Fields 2: Document Understanding - Create & Configure Fields

Create the new label by assigning it at least once. This is the initial step to introduce a new category or classification within your data taxonomy.

Search for instances in the reviewed data where the new label should have been assigned, and apply the label accordingly. This step is crucial for maintaining consistency across your data set.

Use 'Missed Label' to find all additional missing examples in the reviewed data. This action helps in identifying and rectifying any instances that may have been overlooked during the initial review.

Check validation to ensure the label is performing as expected, and follow recommended actions if further training is required. Validation is key to assess the accuracy and performance of the new label within the system.

To enable the Taxonomy Manager button in the Ribbon, the UiPath.IntelligentOCR.Activities package must be installed. This package includes all activities related to Document Understanding, including the Taxonomy Manager.

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.

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

The Quality of Service (QoS) feature in UiPath Communications Mining is designed to monitor and measure the quality of service within a communications channel. It helps businesses understand how well their communications are being managed by evaluating different performance metrics such as response times and the quality of interactions. QoS ensures that communications are aligned with service level agreements and business expectations.

(Source: UiPath Communications Mining documentation)

The best practice is to select an ML Extractor based on document types, language, and data quality. Choosing a model specifically optimized for the type of document being processed ensures higher accuracy and reliability. The quality and diversity of the training data used to develop the model play a significant role in its performance.

UiPath provides out-of-the-box pre-trained models that are ready for use and cover a wide variety of document types. These models can be used as-is for common use cases or fine-tuned based on specific requirements, making them versatile for different projects

 A project in UiPath AI Center is an isolated group of resources (datasets, pipelines, packages, skills, and logs) that you use to build a specific ML solution. You can create, edit, or delete projects from the Projects page or the project’s Dashboard page. However, you can only delete a project if it does not have any package currently deployed in a skill. A package is a versioned and deployable unit of an ML model or an OS script that can be used to create an ML skill. A skill is a consumer-ready, live deployment of a package that can be used in RPA workflows in Studio. If a project has a package deployed in a skill, you need to undeploy the skill first before deleting the project. This is to ensure that you do not accidentally delete a project that is being used by a skill12.

References: 1: AI Center - Managing Projects 2: AI Center - Managing ML Skills

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.

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

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​

The expression does the following:

It uses the subTotalAdditions variable, which is a list of field names that represent the line amounts in the document.

It uses the Select method to apply a function to each element of the list. The function takes a field name as an argument and returns the value of the corresponding document field converted to a decimal number using the CDec function.

It uses the ToList method to convert the result of the Select method into a list of decimal numbers.

It uses the Sum method to calculate the sum of the elements in the list.

It adds the subtotal variable, which is another decimal number, to the sum.

The expression returns the total amount of the document, which is the sum of all the line amounts and the subtotal.

References:

VB.NET - Select Method

VB.NET - CDec Function

VB.NET - ToList Method

[VB.NET - Sum Method]

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.

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.

The Custom Named Entity Recognition out-of-the-box model is a machine learning package that allows you to bring your own dataset tagged with entities you want to extract from unstructured text. The model can be trained and deployed using the UiPath AI Center, and can be integrated with the UiPath Document Understanding framework. The model can be used to extract and classify text in various domains and formats, such as emails, letters, web pages, research papers, and call transcripts. For example, you can use the model to extract information such as names, dates, addresses, amounts, products, or any other custom entity from your documents. The model supports multiple languages and can be customized according to your needs.

References: AI Center - Custom Named Entity Recognition, Custom Named Entity Recognition Documentation, UiPath AI Center - Document Understanding & Use of UiPath Custom Named Entity Recognition Model

The model rating is a proprietary score that assesses the overall health and performance of a model in UiPath Communications Mining. It considers four main factors: balance, underperforming labels, coverage, and all labels. The model rating is a score from 0 to 100, which equates to a rating of ‘Poor’ (0-49), ‘Average’ (50-69), ‘Good’ (70-89) or ‘Excellent’ (90-100). A model rating of 70-90 or better indicates that the model has sufficient training and performs well in all of the most important areas. A model rating of 70-90 or better also means that the model has a balanced and representative training data, a low number of labels with performance issues or warnings, a high coverage of the dataset by informative labels, and a high average precision of all labels.

References: Communications Mining - Model Rating, Communications Mining - Understanding and improving model performance

UiPath provides three types of classifier trainers to optimize document classification: Keyword Based Classifier Trainer, Intelligent Keyword Classifier Trainer, and Machine Learning Classifier Trainer. These trainers are used to teach the system how to categorize documents based on keywords, intelligent learning patterns, or machine learning techniques for more complex classifications.(Source: UiPath Classifier Trainer documentation​

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

 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

To enable a remote knowledge worker to validate the extracted data from documents in Action Center, the automation workflow needs to include the following activities12:

Create Document Validation Action: This activity creates an action of type Document Validation in Orchestrator Action Center, and returns an action object as output. The action object contains the information needed to resume the workflow after the human validation is completed. The input properties of this activity include the action details, such as title, priority, catalog, and folder, and the document validation data, such as the document object model, the document text, the taxonomy, and the automatic extraction results.

Wait for Document Validation Action and Resume: This activity suspends the execution of the workflow until the human validation is done in Action Center, and then resumes it with the updated extraction results. The input property of this activity is the action object obtained from the Create Document Validation Action activity. The output property is the validated extraction results, which can be used for further processing or exporting.

References: 1: Create Document Validation Action 2: Wait for Document Validation Action and Resume

In UiPath AI Center, datasets can only be deleted if they are not being utilized in any active pipelines. This ensures that datasets tied to running or scheduled operations are not inadvertently deleted, which could disrupt ongoing processes. Once the dataset is confirmed to be unused in any active pipeline, it can safely be removed​

In UiPath Communications Mining, Dashboards are fully customizable pages that allow users to display relevant charts, visualizations, and insights for a specific dataset. These dashboards provide critical insights into the performance of models, labels, and other metrics relevant to the communication mining process. Users can create and adjust these dashboards to reflect specific data points, making them a powerful tool for tracking and improving model performance over time.

For more details, refer to:

UiPath Communications Mining Dashboards: Customizing Dashboards

UiPath AI Center Documentation: Dashboards and Visualization

According to the UiPath documentation, a data source is a raw collection of verbatims, which are text-based communications such as survey responses, emails, transcripts, or calls1. A data source can be of a similar type and share a similar intended purpose, such as capturing customer feedback or servicing requests2. A data source can be added to up to 10 different datasets, which are collections of sources and labels that are used to train and evaluate ML models3. Therefore, the correct definition of a UiPath Communications Mining data source is A.

References:

1: Communications Mining - Sources 2: Communications Mining - Managing Sources and Datasets 3: Communications Mining - Understanding the data structure and permissions

The Present Classification Station activity is used for classification validation in attended mode. It allows the user to review and correct the classification results of documents using the Classification Station interface. The other options are not suitable for attended mode, as they are either used for creating Action Center tasks (A and C) or for training classifiers (B).

References: Classification Station - UiPath Documentation Portal, Document Classification Validation Overview - UiPath Documentation Portal.

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

 The ML Extractor is a data extraction tool that uses machine learning models provided by UiPath to identify and extract data from documents. The ML Extractor can work with predefined document types, such as invoices, receipts, purchase orders, 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 Extractor should be chosen based on the document types, language, and data quality of the documents being processed. It is important to select an ML Extractor that is specifically trained or optimized for the document types that are relevant for the use case, as different document types may have different layouts, fields, and formats. It is also important to take into account the language of the documents, as some ML Extractors may support only certain languages or require specific language settings. Moreover, it is important to consider the quality and diversity of the training data used to train the ML Extractor, as this may affect the accuracy and reliability of the extraction results. The training data should be representative of the real-world data, and should cover various scenarios, variations, and exceptions3.

References: 1: Machine Learning Extractor - UiPath Activities 2: Machine Learning Classifier Trainer - UiPath Document Understanding 3: Data Extraction - UiPath Document Understanding

In a Document Understanding Process, particularly when it is in production, it is crucial to manage output data securely and efficiently. Utilizing Network Attached Storage (NAS) and Orchestrator Buckets are recommended practices for exporting result files for several reasons:

Network Attached Storage (NAS): NAS is a dedicated file storage that allows multiple users and client devices to retrieve data from centralized disk capacity. Using NAS in a production environment for storing result files is beneficial due to its accessibility, capacity, and security features. It facilitates easy access and sharing of files within a network while maintaining data security.

Orchestrator Bucket: Orchestrator Buckets in UiPath are used for storing files that can be easily accessed by the robots. This is particularly useful in a production environment because it provides a centralized, cloud-based storage solution that is scalable, secure, and accessible from anywhere. This aligns with the best practices of maintaining high availability and security for business-critical data.

The other options (B, C, and D) include locations that might not be as secure or efficient for a production environment. For example, storing files locally or in a temp folder can pose security risks and is not scalable for large or distributed systems. Similarly, storing directly on a VM might not be the most efficient or secure method, especially when dealing with sensitive data.

When you create a training dataset for document classification or data extraction, you need to split your documents into two subsets: one for training the model and one for evaluating the model. The training subset is used to teach the model how to recognize the patterns and features of your document types and fields. The evaluation subset is used to measure the performance and accuracy of the model on unseen data. The evaluation subset should not be used for training, as this would bias the model and overfit it to the data1.

The recommended split of documents for training and evaluation depends on the size and diversity of your data. However, a general guideline is to use a 70/30 or 80/20 ratio, where 70% or 80% of the documents are used for training and 30% or 20% are used for evaluation. This ensures that the model has enough data to learn from and enough data to test on. For example, if you have 15 documents per vendor, you can use 10 documents for training and 5 documents for evaluation. This would give you a 67/33 split, which is close to the 70/30 ratio. You can also use the Data Manager tool to create and manage your training and evaluation datasets2.

References: 1: Document Understanding - Training High Performing Models 2: Data Manager - Creating a Dataset

According to the UiPath documentation, a UiPath Communications Mining taxonomy is a collection of all the labels applied to the verbatims in a dataset, structured in a hierarchical manner. Labels are the concepts and intents that you want to capture in the dataset to suit your specific objectives. When you import your taxonomy from a spreadsheet, you need to provide the label descriptions, which are the names of the labels and their level in the hierarchy. Label predictions and entity predictions are the outputs of the model training process, and they are not part of the taxonomy. Entity descriptions are the definitions of the entities that you want to extract from the verbatims, and they are not part of the taxonomy either.

References:

Communications Mining - Taxonomies

Communications Mining - Importing your taxonomy

Communications Mining - Building your taxonomy structure

The Configure Extractors Wizard is a tool that enables you to select and customize the extractors that are used for data extraction from documents. It is accessed via the Data Extraction Scope activity, which is a container for extractor activities. The wizard allows you to map the fields defined in your taxonomy with the fields supported by each extractor, and to set the minimum confidence level and the framework alias for each extractor. The wizard is mandatory for the extractor configuration, as it ensures that the extractors are applied correctly to each document type and field1.

References: Configure Extractors Wizard of Data Extraction Scope

UiPath Communications Mining is a new capability to understand and automate business communications. It uses state-of-the-art AI models to turn business messages—from emails to tickets—into actionable data. It does this in real time and on all major business communications channels1. Natural Language Processing (NLP) is the branch of AI that deals with analyzing, understanding, and generating natural language. NLP enables UiPath Communications Mining to extract the most important data from any message, such as reasons for contact, data fields, and sentiment2. NLP also allows UiPath Communications Mining to deploy custom AI models in hours, not weeks, by using automatic labeling and annotation2.

References: 2 Communications Mining - Automate Business Communications | UiPath 1 Introducing UiPath Communications Mining | UiPath

In UiPath Communications Mining, general fields that are trained from scratch require user-defined inputs and training data, making them highly customizable but dependent on the specific data provided by the user. In contrast, pre-trained general fields are based on predefined rules and training models developed by UiPath. These pre-trained fields offer out-of-the-box functionality and are optimized for common use cases, whereas user-trained fields offer more flexibility to meet specific business requirements.

(Source: UiPath Communications Mining documentation)

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

In UiPath Communications Mining, the precision and recall statistics for specific labels are primarily determined by the confidence threshold set for the model. This threshold represents the level of certainty the model needs before it assigns a label to a message. By adjusting this threshold, you can trade off between precision (fewer false positives) and recall (fewer false negatives). For instance, a higher threshold will increase precision but may reduce recall, and vice versa​

The End Process is the final stage of the Document Understanding Process, which is a fully functional UiPath Studio project template based on a document processing flowchart. The End Process is responsible for setting the queue transaction status, logging the results, and performing any post processing or cleaning actions if needed. The End Process sets the queue transaction status as Successful if the document was processed without any exception, and as Failed if an exception occurred, either a Business Exception (such as invalid data) or a System Exception (such as network failure). The End Process also adds the extracted data and the validation status as output arguments to the queue transaction. The End Process also logs the processing statistics, such as the number of documents processed, the number of exceptions, the average processing time, and the accuracy rate. The End Process also performs any post processing or cleaning actions, such as deleting temporary files, closing applications, or sending notifications1.

References: 1: Document Understanding Process: Studio Template

In UiPath Document Understanding Cloud APIs, the Generative Classifier is used to classify documents by leveraging a generative AI model. To classify a document as either an "Invoice" or a "Receipt," a POST request must be sent to the /api/framework/projects/{projectId}/classifiers/generative_classifier/classification endpoint. The body of this request should contain prompts specifying the classification types (in this case, "Invoice" and "Receipt") along with their corresponding descriptions. This allows the model to correctly classify incoming documents based on these predefined prompts.

For further reading, refer to:

UiPath Document Understanding API Documentation: Cloud API for Classification

Generative Classifier APIs: UiPath Classification APIs

According to the UiPath documentation portal1, the Document Understanding Process is a fully functional UiPath Studio project template based on a document processing flowchart. It provides logging, exception handling, retry mechanisms, and all the methods that should be used in a Document Understanding workflow, out of the box. The Document Understanding Process is preconfigured with a series of basic document types in a taxonomy, a classifier configured to distinguish between these classes, and extractors to showcase how to use the Data Extraction capabilities of the framework. It is meant to be used as a best practice example that can be adapted to your needs while displaying how to configure each of its components1. The Document Understanding Framework, on the other hand, is a set of activities that can be used to build custom document processing workflows. The framework facilitates the processing of incoming files, from file digitization to extracted data validation, all in an open, extensible, and versatile environment. The framework enables you to combine different approaches to extract information from multiple document types. The framework consists of several components, such as Taxonomy, Digitization, Classification, Data Extraction, Data Validation, and Data Consumption2. Therefore, option D is the correct answer, as it describes the difference between the Document Understanding Process and the Document Understanding Framework.

References: 1 Document Understanding Process: Studio Template 2 Document Understanding - Introduction

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​

In UiPath's Communications Mining, the label category "Process / Request types" is often mapped to a service catalog. This label category is used to identify different types of processes or service requests that are common in customer communications. It enables automation processes to classify incoming communications into distinct service categories, which are typically mapped to entries in a service catalog. This allows organizations to handle customer inquiries more effectively by routing them to the correct department or service line based on the classification provided by this label category.

For example, if a communication relates to a request for support or a service inquiry, it would be classified under "Process / Request types," allowing it to be mapped directly to an appropriate service in the service catalog.

For more details, refer to:

UiPath Communications Mining Documentation: Label Categories

Communications Mining Process Categories: UiPath AI Communications Mining

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 correct pipeline configuration for creating a new model version that includes both the initial 1000 pages and the newly labeled 800 pages is to run a Full pipeline. This ensures that the model is fully retrained with all available data (1800 pages in total). The evaluation dataset should remain the 100 pages to gauge the model's performance after retraining. This approach maximizes the model's learning by incorporating all labeled data while allowing for evaluation against a known dataset.