Optimizing user interaction and task selection in large-scale language models

Abstract

Data representing the text query is received. Text embeddings for the text query are generated using a machine learning-based embedding generation model. Multiple chunk embeddings, each generated by an embedding generation model for multiple document chunks of multiple documents, are accessed. Multiple documents are organized into multiple document subsets. Data representing the selected(s) document subsets is retrieved. A similarity search for text embeddings is performed only on chunk embeddings associated with the document chunks contained within the selected(s) document subsets. The similarity search identifies chunk embeddings as semantically similar to the text query. The document chunks corresponding to the chunk embeddings identified by the similarity search are provided for display within the user interface.

Description

Technical Field

[0001] This disclosure generally relates to optimizing task execution using large language models. More specifically, this disclosure relates to optimizing interactions between a user and a large language model while selecting tasks for the large language model.

Background Art

[0002] Large language models are models trained on vast datasets. This training method provides large language models with the ability to execute multiple types of language tasks. For example, some language models can simplify text, generate opposing opinions, facilitate brainstorming, and respond conversationally to user queries. By using these tasks in combination, it is possible to promote conversation-based interaction between the model and the user and more efficiently provide relevant information to the user. However, the wide variety of tasks that large language models can execute makes it difficult to always select a specific task (or tasks).

Summary of the Invention

Problems to be Solved by the Invention

[0003] Aspects and advantages of embodiments of this disclosure are described in part in the following description, or can be learned from the description, or can be learned through the practice of the embodiments.

[0004] One exemplary aspect of this disclosure relates to a computer-implemented method for semantic search of a specified subset of multiple documents. The method includes receiving data indicating a text query by a computing system comprising one or more computing devices. The method includes generating text embeddings for the text query by the computing system using a machine learning-based embedding generation model. The method includes accessing a plurality of chunk embeddings generated by the machine learning-based embedding generation model for a plurality of document chunks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets. The method includes obtaining data indicating one or more selected document subsets from the plurality of document subsets by the computing system. The method includes performing a similarity search for text embeddings with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, wherein the similarity search identifies one or more chunk embeddings as semantically similar to the text query. The method includes providing one or more of a plurality of document chunks corresponding to one or more of the chunk embeddings identified by the similarity search for display within a user interface by the computing system.

[0005] Other exemplary aspects of this disclosure relate to a computer system for semantic retrieval of a specified subset of multiple documents. The computer system includes one or more processors and one or more non-temporary computer-readable media. The one or more non-temporary computer-readable media collectively store multiple chunk embeddings, each generated by a machine learning-based embedding generation model for multiple document chunks of the multiple documents, and the multiple documents are organized into multiple document subsets. The one or more non-temporary computer-readable media collectively store instructions that, when executed by one or more processors, cause the computer system to perform an action. This action includes receiving data indicating a text query. This action includes generating text embeddings for the text query using a machine learning-based embedding generation model. This action includes retrieving data indicating one or more selected document subsets of the multiple document subsets. This action includes performing a similarity search for text embeddings with respect only to chunk embeddings associated with document chunks contained in one or more selected document subsets, the similarity search identifies one or more chunk embeddings as semantically similar to the text query. This operation includes providing one or more document chunks corresponding to one or more chunk embeddings identified by similarity search, for display within the user interface.

[0006] Other exemplary aspects of this disclosure relate to computer-implemented methods for improved explainability of large-scale language model interactions. The method includes a computing system comprising one or more computing devices receiving data representing a text query. The method includes the computing system generating text embeddings for the text query using a machine learning-based embedding generation model. The method includes the computing system performing a similarity search for text embeddings with respect to a plurality of chunk embeddings generated by the machine learning-based embedding generation model for a plurality of document chunks of a plurality of documents, wherein the similarity search identifies one or more identified document chunks of the plurality of document chunks as semantically similar to the text query. The method includes the computing system generating a prompt containing one or more identified document chunks. The method includes the computing system providing the prompt for processing by the machine learning-based large-scale language model as input to the machine learning-based large-scale language model. The method includes the computing system receiving language output generated by the machine learning-based large-scale language model based on the processing of the prompt. The method includes the computing system providing language output as output.

[0007] Other exemplary aspects of this disclosure relate to a computer system for large-scale language model interaction with improved explainability. The computer system includes one or more processors and one or more non-temporary computer-readable media that, when executed by one or more processors, collectively store instructions causing the computer system to perform an action. This action includes receiving data indicating a text query. This action includes generating text embeddings for the text query using a machine learning-trained embedding-generating model. This action includes performing a similarity search for text embeddings with respect to a plurality of chunk embeddings generated by the machine learning-trained embedding-generating model for a plurality of document chunks of a plurality of documents, the similarity search identifying one or more identified document chunks of the plurality of document chunks as semantically similar to the text query. This action includes generating a prompt containing one or more identified document chunks. This action includes providing the prompt as input to a machine learning-trained large-scale language model for processing by the machine learning-trained large-scale language model. This action includes receiving language output generated by the machine learning-trained large-scale language model based on the processing of the prompt. This action includes providing language output as output.

[0008] Other exemplary aspects of this disclosure relate to one or more non-temporary computer-readable media that, when executed by one or more processors of a computing system, store instructions that cause the computing system to perform an action. This action includes receiving data indicating a text query. This action includes generating text embeddings for the text query using a machine learning-trained embedding-generating model. This action includes performing a similarity search for text embeddings with respect to a plurality of chunk embeddings generated by the machine learning-trained embedding-generating model for a plurality of document chunks of a plurality of documents, wherein the similarity search identifies one or more identified document chunks of the plurality of document chunks as semantically similar to the text query. This action includes generating a prompt containing one or more identified document chunks. This action includes providing the prompt as input to a machine learning-trained large-scale language model for processing by the machine learning-trained large-scale language model. This action includes receiving language output generated by the machine learning-trained large-scale language model based on the processing of the prompt. This action includes providing language output as output.

[0009] Other aspects of this disclosure cover a variety of systems, apparatus, non-temporary computer-readable media, user interfaces, and electronic devices.

[0010] These and other features, aspects and advantages of the various embodiments of this disclosure will be better understood by referring to the following description and the appended claims. The appended drawings incorporated herein and forming part of this specification illustrate exemplary embodiments of this disclosure and, together with the description, serve to illustrate the relevant principles.

[0011] A detailed description of embodiments intended for those skilled in the art is given herein with reference to the accompanying drawings. [Brief explanation of the drawing]

[0012] [Figure 1A] A block diagram of an exemplary computing system that performs user interaction and task selection optimization for a large language model according to an exemplary embodiment of the present disclosure is shown. [Figure 1B] The following is a block diagram of an exemplary computing device that performs a semantic search of a specific subset of multiple documents according to an exemplary embodiment of the present disclosure. [Figure 1C] The following is a block diagram of an exemplary computing device that performs the simplification of selecting specific language tasks to enhance user interaction with a large language model, according to an exemplary embodiment of the present disclosure. [Figure 2] A block diagram of an exemplary machine learning-trained large-scale language model according to an exemplary embodiment of the present disclosure is shown. [Figure 3] A block diagram of an exemplary machine learning-prepared language model ensemble according to an exemplary embodiment of the present disclosure is shown. [Figure 4] This disclosure presents exemplary user interfaces for facilitating interaction between users and large language models, based on several embodiments of this disclosure. [Figure 5A] The following illustrates user interaction with an exemplary user interface in Figure 4 for assigning documents to document subsets, according to several embodiments of this disclosure. [Figure 5B] The following illustrates user interaction with an exemplary user interface for assigning documents to document subsets, according to several other embodiments of this disclosure. [Figure 6A] The present disclosure illustrates user interaction with an exemplary user interface in Figure 4 for selecting a document subset from multiple document subsets, according to several embodiments of this disclosure. [Figure 6B] The following illustrates user interaction with the exemplary user interface shown in Figure 4 for providing queries via a query field, according to several embodiments of this disclosure. [Figure 7A] This disclosure illustrates user interaction with a large language model using exemplary user interfaces for requesting the model to perform a summarization task, as described in several embodiments of this disclosure. [Figure 7B] Some embodiments of this disclosure demonstrate additional user interaction with large language models using exemplary user interfaces for requesting the model to perform a counter-perspective task. [Figure 7C] Some embodiments of this disclosure demonstrate additional user interaction with large language models using exemplary user interfaces for requesting the model to perform brainstorming tasks. [Figure 7D] Some embodiments of this disclosure demonstrate additional user interaction with large language models using exemplary user interfaces for requesting the model to perform simplification tasks. [Figure 8] This disclosure shows various interface layouts that can implement the interface shown in the previous figure according to some embodiments of this disclosure. [Figure 9] A flowchart illustrating an exemplary method for performing a semantic search of a specific subset of multiple documents, according to an exemplary embodiment of the present disclosure, is shown. [Figure 10] A flowchart illustrating an exemplary method for performing large-scale language model interactions with improved explainability, according to exemplary embodiments of the present disclosure, is shown. [Figure 11] A flowchart illustrating an exemplary method for performing the selection of specific language tasks to enhance user interaction with a large language model, according to exemplary embodiments of this disclosure, is shown. [Figure 12] A flowchart illustrating an exemplary method for performing dynamic selection of tasks for large-scale language models, according to exemplary embodiments of this disclosure, is shown. [Modes for carrying out the invention]

[0013] Reference numbers that are repeated across multiple drawings are intended to identify the same features in various embodiments.

[0014] Summary Generally, the present disclosure is directed to optimizing task execution using large language models. More specifically, the present disclosure relates to optimizing interactions between a user and a large language model while selecting tasks for the large language model. As an example, a computing system can obtain a text query from a user. The text query can be processed by a machine-learned embedding generation model to generate a text embedding of the query. This query can be used to access a plurality of chunk embeddings in an embedding space. Each chunk embedding can correspond to a respective chunk of a document, and the documents can be organized into various document subsets. For example, a user can collect 10 different types of documents (e.g., articles, patent documents, research papers, websites, etc.) and sort them into document subsets by type (e.g., if 4 of the 10 documents are patent documents, they can be sorted into their own document subset).

[0015] The computing system can obtain data indicating that the user has selected one of the document subsets. Next, the computing system can perform a similarity search between the query embedding and only the chunk embeddings associated with the chunks of the documents included in the selected document subset to identify one or more identified document chunks.

[0016] In some embodiments, identified document chunks may be provided directly to the user within a user interface. For example, a user may be interacting with a word processing application, and identified document chunks may be provided within the margins of a Word document. In other examples, identified document chunks may be provided within some interface and may include attribute information (e.g., citations) indicating the location of each document chunk within each document.

[0017] Additionally, or alternatively, in some embodiments, the computing system can utilize identified document chunks as input for a large-scale language model to provide more information to the user. For example, the computing system can generate prompts containing identified document chunks. The computing system can provide prompts as input to a machine-learned large-scale language model (e.g., it can process prompts using the model, or provide prompts to a remote service implementing the model), and can receive language output generated by the model. The language output can then be provided to the user.

[0018] In some embodiments, the user can specify a particular task that a machine-trained large-scale language model (MEL) will perform. For example, the user interface may include various selectable task elements corresponding to specific tasks that the MLM-trained large-scale language model can perform (e.g., simplification tasks, summarization tasks, counter-perspective tasks, etc.). The computing system can obtain information indicating that the user has selected one of the task elements. The computing system can then use the MLM-trained large-scale language model to perform the task corresponding to the task element and obtain a large-scale language output that satisfies the task. In a particular example, the computing system can obtain information indicating that the user has selected a summarization task. The computing system can use the MLM-trained large-scale language model to process the identified document chunk(s) and obtain language output. The computing system can then use the MLM-trained large-scale language model to generate a summary output that summarizes the language output. Alternatively, instead of generating language output, the computing system can generate an initial language output that summarizes the identified document chunk(s).

[0019] Alternatively, in some embodiments, the computing system can automatically determine which task to select for execution by a machine learning-trained large-scale language model. For example, the computing system can identify identified document chunks and / or determine that the identified document chunks and / or text queries from the user represent a particular viewpoint. Based on the identified document chunks and / or text queries, the computing system can select an opposite viewpoint task. The computing system can then use the machine learning-trained large-scale language model to generate language output that describes a viewpoint opposite to the viewpoint represented by the identified document chunks and / or query text. In this way, the computing system can facilitate interaction between the user and the machine learning-trained large-scale language model to optimize the delivery of information to the user.

[0020] Embodiments of this disclosure offer several technical effects and benefits. One example of these technical effects and benefits is that users of conventional search processes, document processing applications, etc., often have to spend a considerable amount of time and effort navigating between references, analyzing references, and examining background information to understand complex concepts. However, by optimizing the interaction between the user and a machine-learned large-scale language model, and by facilitating the selection of model tasks, embodiments of this disclosure can significantly reduce the time users spend using computing devices to conduct research. For example, instead of a user spending hours manually searching complex academic papers for information, embodiments of this disclosure can optimize the interaction between the user and the large-scale language model, providing the user with the same information in minutes. As a result, this eliminates the need to consume a substantial amount of computing resources (e.g., compute cycles, power, memory, etc.) that a user would normally use. Furthermore, by reducing user time loss, embodiments of this disclosure can increase efficiency across several use cases (e.g., software engineering, medical research, literature citation for research papers, etc.).

[0021] Illustrative embodiments of the present disclosure are described in further detail here with reference to the drawings.

[0022] Exemplary devices and systems Figure 1A shows a block diagram of an exemplary computing system 100 that performs user interaction and task selection optimization for a large language model according to an exemplary embodiment of the present disclosure. The system 100 includes a user computing device 102, a server computing system 130, and a training computing system 150, all of which are communicably coupled via a network 180.

[0023] The user computing device 102 may be any type of computing device, such as a personal computing device (e.g., a laptop or desktop), a mobile computing device (e.g., a smartphone or tablet), a game console or controller, a wearable computing device, an embedded computing device, or any other type of computing device.

[0024] The user computing device 102 includes one or more processors 112 and memory 114. The one or more processors 112 may be any suitable processing device (e.g., a processor core, microprocessor, ASIC, FPGA, controller, microcontroller, etc.) and may be one processor or multiple processors connected in an operable manner. The memory 114 may include one or more non-temporary computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. The memory 114 can store data 116 and instructions 118 executed by the processors 112 to cause the user computing device 102 to perform operations.

[0025] In some embodiments, the user computing device 102 may store or include one or more models 120. For example, the models 120 may be various machine learning models such as neural networks (e.g., deep neural networks), large-scale language models (LLMs), or other types of machine learning models including nonlinear and / or linear models, or may otherwise include them. Neural networks may include feedforward neural networks, recurrent neural networks (e.g., long-short-term memory recurrent neural networks), convolutional neural networks, or other forms of neural networks. Some exemplary machine learning models may utilize attention mechanisms such as self-attention. For example, some exemplary machine learning models may include multi-head self-attention models (e.g., transformer models). Exemplary models 120 are described with reference to Figures 2 and 3.

[0026] In some embodiments, one or more models 120 can be received from a server computing system 130 via a network 180, stored in the memory 114 of a user computing device, and then used or otherwise implemented by one or more processors 112. In some embodiments, the user computing device 102 can implement multiple parallel instances of a single model 120 (for example, to perform parallel optimization of user interaction and task selection for a large language model across multiple instances of the model 120).

[0027] More specifically, the model(s) 120 may, in some embodiments, include a machine learning-based embedding generator model. The machine learning-based embedding generator model can be any type or method of model(s) (e.g., a model architecture including multiple models) sufficient to generate an intermediate representation of a query. In some embodiments, the query may be a text query, and the machine learning-based embedding generator model may generate text embeddings for the text query. Alternatively, in some embodiments, the query may be an image query, a video query, a gesture query, a context query (e.g., a query including contextual information (e.g., location, pose, environment, time, etc.), a multimodal query (e.g., text and image inputs, etc.)), and the machine learning-based embedding generator model may generate an intermediate representation (e.g., embeddings) for the query.

[0028] Additionally or alternatively, in some embodiments, model(s)120 may include a machine learning-based large-scale language model. The machine learning-based large-scale language model may be a model trained on a large corpus of language training data, or otherwise include such a model, in a way that provides the machine learning-based large-scale language model with the ability to perform multiple language tasks. For example, the machine learning-based large-scale language model may be trained to perform summarization tasks, conversation tasks, simplification tasks, opposite-point-of-view tasks, and so on. In particular, the machine learning-based large-scale language model may be trained to process various outputs and generate language outputs. For example, the machine learning-based large-scale language model may process embeddings generated by a machine learning-based embedding generation model, document chunk(s) identified using the embedding generation model, the machine learning-based large-scale language model, or other models, and so on.

[0029] Additionally or alternatively, one or more Model 140 may be included in a server computing system 130 that communicates with a user computing device 102 according to a client-server relationship, or may be stored and implemented by the server computing system 130 in other ways. For example, Model 140 may be implemented by the server computing system 130 as part of a web service (e.g., a document processing service). Thus, one or more Model 120 may be stored and implemented in the user computing device 102, and / or one or more Model 140 may be stored and implemented in the server computing system 130.

[0030] Furthermore, the user computing device 102 may include one or more user input components 122 that receive user input. For example, the user input component 122 may be a touch-sensitive component (e.g., a touch-sensitive display screen or touchpad) that is sensitive to the touch of a user input object (e.g., a finger or stylus). The touch-sensitive component may function to implement a virtual keyboard. Other exemplary user input components include a microphone, a conventional keyboard, or other means by which the user can provide user input.

[0031] The server computing system 130 includes one or more processors 132 and memory 134. The one or more processors 132 may be any suitable processing device (e.g., a processor core, microprocessor, ASIC, FPGA, controller, microcontroller, etc.) and may be one processor or multiple processors connected in an operable manner. The memory 134 may include one or more non-temporary computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, and combinations thereof. The memory 134 can store data 136 and instructions 138 executed by the processors 132 to cause the server computing system 130 to perform operations.

[0032] In some embodiments, the server computing system 130 includes or is implemented by one or more server computing devices. If the server computing system 130 includes multiple server computing devices, such server computing devices may operate according to a sequential computing architecture, a parallel computing architecture, or any combination thereof.

[0033] As described above, the server computing system 130 may store or otherwise include one or more models 140. For example, model 140 may be various machine learning models or may otherwise include various machine learning models. Exemplary machine learning models include neural networks or other multi-layer nonlinear models. Exemplary neural networks include feedforward neural networks, deep neural networks, recurrent neural networks, and convolutional neural networks. Some exemplary machine learning models may utilize attention mechanisms such as self-attention. For example, some exemplary machine learning models may include multi-head self-attention models (e.g., transformer models). Exemplary models 140 are described with reference to Figures 2 and 3.

[0034] Specifically, the model(s) 140 of the server computing system 130 may include some or all of the model(s) 120 contained in the user computing device 102, and such models may be provided as a service for the user computing device 102. For example, in some embodiments, the model(s) 140 may include a machine learning-based embedding generation model. The server computing system 130 may also maintain an embedding space containing embeddings generated using the machine learning-based embedding generation model. The user computing device 102 may provide queries to the server computing system 130, and the server computing system 130 may process the queries using the machine learning-based embedding generation model to obtain an intermediate representation of the queries.

[0035] In some embodiments, the server computing system 130 can return an intermediate representation of the query to the user computing device 102. Alternatively, in some embodiments, the machine learning model(s) 140 may include a machine learning large-scale language model, and the server computing system 130 can process the intermediate representation using the machine learning large-scale language model to obtain language output. The language output, or information indicating or otherwise describing the language output, can be provided to the user computing device 102.

[0036] The user computing device 102 and / or the server computing system 130 can train models 120 and / or 140 by interacting with a training computing system 150 which is connected to it communicatively via a network 180. The training computing system 150 may be separate from the server computing system 130 or may be part of the server computing system 130.

[0037] The training computing system 150 includes one or more processors 152 and memory 154. The one or more processors 152 may be any suitable processing device (e.g., a processor core, microprocessor, ASIC, FPGA, controller, microcontroller, etc.) and may be one processor or multiple operably connected processors. The memory 154 may include one or more non-temporary computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, magnetic disks, etc., and combinations thereof. The memory 154 can store data 156 and instructions 158 executed by the processors 152 to cause the training computing system 150 to perform operations. In some embodiments, the training computing system 150 includes one or more server computing devices or is otherwise implemented by them.

[0038] The training computing system 150 may include a model trainer 160 that trains machine-learned models 120 and / or 140 stored on the user's computing device 102 and / or server computing system 130 using various training or learning techniques, such as backpropagation. For example, a loss function may be backpropagated through the model(s) to update one or more parameters of the model(s) (e.g., based on the gradient of the loss function). Various loss functions can be used, such as mean squared error, likelihood loss, cross-entropy loss, hinge loss, and / or various other loss functions. Gradient descent techniques can be used to iteratively update parameters for several training iterations.

[0039] In some embodiments, performing backpropagation may include performing truncated diachronic backpropagation. The model trainer 160 may perform several generalization techniques (e.g., weight decay, dropout, etc.) to improve the generalization ability of the model being trained.

[0040] Specifically, the model trainer 160 can train models 120 and / or 140 based on a set of training data 162. The training data 162 can include, for example, a corpus.

[0041] In some embodiments, if the user gives consent, training examples can be provided by the user computing device 102. Thus, in such embodiments, the model 120 provided to the user computing device 102 can be trained by the training computing system 150 with user-specific data received from the user computing device 102. In some examples, this process may be called model personalization.

[0042] The model trainer 160 includes computer logic used to provide a desired function. The model trainer 160 can be implemented in hardware, firmware, and / or software that control a general-purpose processor. For example, in some embodiments, the model trainer 160 includes a program file stored in a storage device, loaded into memory, and executed by one or more processors. In other embodiments, the model trainer 160 includes one or more sets of computer executable instructions stored in RAM, a hard disk, or a tangible computer-readable storage medium such as an optical or magnetic medium.

[0043] Network 180 may be any type of communication network, such as a local area network (e.g., an intranet), a wide area network (e.g., the Internet), or a combination thereof, and may include any number of wired or wireless links. In general, communication over Network 180 can be transmitted over any type of wired and / or wireless connection using a wide variety of communication protocols (e.g., TCP / IP, HTTP, SMTP, FTP), encodings or formats (e.g., HTML, XML), and / or protection methods (e.g., VPN, Secure HTTP, SSL).

[0044] In some embodiments, the input to the machine learning model(s) of this disclosure may be image data. The machine learning model(s) may process the image data to produce an output. For example, the machine learning model(s) may process the image data to produce an image recognition output (e.g., recognition of image data, latent embedding of image data, encoded representation of image data, hash of image data, etc.). As another example, the machine learning model(s) may process the image data to produce an image segmentation output. As yet another example, the machine learning model(s) may process the image data to produce an image classification output. As yet another example, the machine learning model(s) may process the image data to produce an image data modification output (e.g., modification of image data, etc.). As yet another example, the machine learning model(s) may process the image data to produce an encoded image data output (e.g., encoded representation and / or compressed representation of image data, etc.). As yet another example, the machine learning model(s) may process the image data to produce an upscaled image data output. As yet another example, the machine learning model(s) may process the image data to produce a prediction output.

[0045] In some embodiments, the input to the machine learning model(s) of this disclosure may be text or natural language data. The machine learning model(s) may process the text or natural language data to produce an output. For example, the machine learning model(s) may process natural language data to produce a language encoding output. As another example, the machine learning model(s) may process text or natural language data to produce a latent text embedding output. As yet another example, the machine learning model(s) may process text or natural language data to produce a translation output. As yet another example, the machine learning model(s) may process text or natural language data to produce a classification output. As yet another example, the machine learning model(s) may process text or natural language data to produce a text segmentation output. As yet another example, the machine learning model(s) may process text or natural language data to produce a semantic intent output. As another example, a machine learning model(s) can process text or natural language data to produce upscaled text or natural language output (e.g., text or natural language data of higher quality than the input text or natural language). As yet another example, a machine learning model(s) can process text or natural language data to produce predictive output.

[0046] In some embodiments, the input to the machine learning model(s) of this disclosure may be speech data. The machine learning model(s) may process the speech data to produce an output. For example, the machine learning model(s) may process speech data to produce a speech recognition output. As another example, the machine learning model(s) may process speech data to produce a speech translation output. As yet another example, the machine learning model(s) may process speech data to produce a latent embedding output. As yet another example, the machine learning model(s) may process speech data to produce an encoded speech output (e.g., an encoded representation and / or compressed representation of the speech data). As yet another example, the machine learning model(s) may process speech data to produce an upscaled speech output (e.g., speech data of higher quality than the input speech data). As yet another example, the machine learning model(s) may process speech data to produce a text representation output (e.g., a text representation of the input speech data). As another example, machine learning models can process speech data and generate predictive outputs.

[0047] In some embodiments, the input to the machine learning model(s) of this disclosure may be latent encoding data (e.g., a latent spatial representation of the input). The machine learning model(s) may process the latent encoding data to produce an output. For example, the machine learning model(s) may process the latent encoding data to produce a recognition output. As another example, the machine learning model(s) may process the latent encoding data to produce a reconstruction output. As yet another example, the machine learning model(s) may process the latent encoding data to produce a search output. As yet another example, the machine learning model(s) may process the latent encoding data to produce a reclustering output. As yet another example, the machine learning model(s) may process the latent encoding data to produce a prediction output.

[0048] In some embodiments, the input to the machine learning model(s) of this disclosure may be statistical data. The statistical data may be, represent, or otherwise include data calculated and / or computed from some other data source. The machine learning model(s) may process the statistical data to produce an output. For example, the machine learning model(s) may process the statistical data to produce a recognition output. As another example, the machine learning model(s) may process the statistical data to produce a prediction output. As yet another example, the machine learning model(s) may process the statistical data to produce a classification output. As yet another example, the machine learning model(s) may process the statistical data to produce a segmentation output. As yet another example, the machine learning model(s) may process the statistical data to produce a visualization output. As yet another example, the machine learning model(s) may process the statistical data to produce a diagnostic output.

[0049] In some embodiments, the input to the machine learning model(s) of this disclosure may be sensor data. The machine learning model(s) may process the sensor data to generate outputs. For example, the machine learning model(s) may process the sensor data to generate recognition outputs. As another example, the machine learning model(s) may process the sensor data to generate prediction outputs. As yet another example, the machine learning model(s) may process the sensor data to generate classification outputs. As yet another example, the machine learning model(s) may process the sensor data to generate segmentation outputs. As yet another example, the machine learning model(s) may process the sensor data to generate visualization outputs. As yet another example, the machine learning model(s) may process the sensor data to generate diagnostic outputs. As yet another example, the machine learning model(s) may process the sensor data to generate detection outputs.

[0050] In some cases, the input includes visual data and the task is a computer vision task. In other cases, the input includes pixel data from one or more images and the task is an image processing task. For example, an image processing task could be image classification, with the output being a set of scores, each corresponding to a different object class and representing the likelihood that one or more images depict an object belonging to that object class. An image processing task could also be object detection, with the output identifying one or more regions within one or more images and, for each region, the likelihood that the region depicts an object of interest. Another example is image segmentation, where the output defines, for each pixel in one or more images, the likelihood for each category within a given set of categories. For example, the set of categories could be foreground and background. Another example is that the set of categories could be object classes. Another example is depth estimation, where the output defines, for each pixel in one or more images, the respective depth value. As another example, the image processing task could be motion estimation, where the network input includes multiple images, and the image processing output defines the motion of the scene depicted between the images in the network input, for each pixel in the input images.

[0051] Figure 1A shows one exemplary computing system that can be used to carry out the present disclosure. Other computing systems can be used in a similar manner. For example, in some embodiments, the user computing device 102 may include a model trainer 160 and a training dataset 162. In such embodiments, the model 120 can be trained or used locally on the user computing device 102. In some such embodiments, the user computing device 102 may implement the model trainer 160 to personalize the model 120 based on user-specific data.

[0052] Figure 1B shows a block diagram of an exemplary computing device 10 that performs a semantic search of a specific subset of multiple documents according to an exemplary embodiment of the present disclosure. The computing device 10 may be a user computing device or a server computing device.

[0053] Computing device 10 contains several applications (e.g., applications 1 to N). Each application contains its own machine learning library and one or more pre-trained models. For example, each application may contain a pre-trained model. Exemplary applications include text messaging applications, email applications, dictation applications, virtual keyboard applications, and browser applications.

[0054] As shown in Figure 1B, each application can communicate with several other components of the computing device, such as one or more sensors, a context manager, a device state component, and / or additional components. In some embodiments, each application can communicate with each device component using an API (e.g., a public API). In some embodiments, the API used by each application is specific to that application.

[0055] Figure 1C shows a block diagram of an exemplary computing device 50 that performs the facilitation of selecting specific language tasks to enhance user interaction with a large language model, according to an exemplary embodiment of the present disclosure. The computing device 50 may be a user computing device or a server computing device.

[0056] The computing device 50 includes several applications (e.g., applications 1 to N). Each application communicates with a central intelligence layer. Exemplary applications include text messaging applications, email applications, dictation applications, virtual keyboard applications, and browser applications. In some embodiments, each application can communicate with the central intelligence layer (and the model(s) stored within it) using an API (e.g., a common API across all applications).

[0057] The central intelligence layer includes several machine learning models. For example, as illustrated in Figure 1C, each machine learning model may be provided for each application and managed by the central intelligence layer. In other embodiments, two or more applications may share a single machine learning model. For example, in some embodiments, the central intelligence layer may provide a single model to all applications. In some embodiments, the central intelligence layer is contained within the operating system of the computing device 50 or is otherwise implemented by the operating system of the computing device 50.

[0058] The central intelligence layer can communicate with the central device data layer. The central device data layer may be a centralized repository of data for the computing device 50. As shown in Figure 1C, the central device data layer can communicate with several other components of the computing device, such as one or more sensors, a context manager, a device state component, and / or additional components. In some embodiments, the central device data layer can communicate with each device component using an API (e.g., a private API).

[0059] Exemplary model placement Figure 2 shows a block diagram of an exemplary machine-learned large language model 200 according to an exemplary embodiment of the present disclosure. In some embodiments, the machine-learned large language model 200 receives a set of input data 204 which are identified document chunks, or otherwise describe them, and is trained to provide output data 206 which describe language outputs as a result of receiving the input data 204.

[0060] In some embodiments, the input data 204 may further indicate a specific task among several tasks that can be performed by the machine-learned large-scale language model 200. For example, the input data 204 may include identified document chunks 204A and indicate a summarization task 204B. The machine-learned large-scale language model 200 may process the input data 204 to generate output data 206 that describes a language output summarizing the identified document chunks.

[0061] Figure 3 shows a block diagram of an exemplary machine learning-prepared language model ensemble 300 according to an exemplary embodiment of the present disclosure. The machine learning-prepared language model ensemble 300 comprises a machine learning-prepared embedding-generating model 302 and a large-scale language model 306, which is similar to the machine learning-prepared large-scale language model 200 in Figure 2, except that the large-scale language model 306 is included in the machine learning-prepared language model ensemble 300 together with the machine learning-prepared embedding-generating model 302.

[0062] As an example, input data 304 may include the specified task 204B and text query 308 in Figure 2. The text query 308 may be a query from a user to a machine learning-trained language model ensemble. The machine learning-trained embedding generation model 302 can process the text query 308 to obtain an intermediate representation 310 of the text query 308. Using the intermediate representation 310, a search of the embedding space 312 containing embeddings generated by the machine learning-trained embedding generation model 302 can be performed. Embeddings are embeddings of chunks of documents organized into subsets 314 of documents.

[0063] Specifically, the machine learning-based embedding generation model 302 can process the intermediate representation 310 to identify chunk embeddings 316 that are semantically similar to the query text 308. The identified document chunks 318 can then be obtained from a subset of documents 320. The identified document chunks 318 are chunks of documents in the subset of documents 320 that correspond to the identified chunk embeddings 316.

[0064] The large-scale language model 306 can process identified document chunks 318 to generate output data 206 that describe the language output. In some embodiments, the large-scale language model 306 can also process or otherwise be configured based on a specified task 204B. For example, the specified task 204B may be a summarization task. The large-scale language model 306 can be configured to perform a summarization task based on the specified task 204B. The large-scale language model 306 can then process identified document chunks 318 to generate output data 206 that can describe the language output, which includes summaries of the identified document chunks 318.

[0065] Exemplary Embodiments Figure 4 shows exemplary user interfaces 400 for facilitating interaction between a user and a large language model, according to several embodiments of the present disclosure. Specifically, interface 400 may be an interface for a document processing application (e.g., a web application). Interface 400 may include a plurality of documents 402A-402Q (generally, document 402). Some of document 402 may be organized into document subsets 404, 406, 408, and 410. Other documents 402 may be unassigned. Following the illustrated example, the first document subset 404 (e.g., document bottle 1) may be a subset of academic papers and may include documents (e.g., academic papers) 402A, 402B, and 402C. The second document subset 406 may be a subset of patent documents and may include documents (e.g., patent documents) 402D, 402E, and 402F. The third document subset 408 may be a subset of newspaper articles or clipping documents and may include documents (e.g., newspaper clippings) 402G, 402H, and 402I. The fourth document subset 410 may be a subset of files (e.g., program instruction files, slide deck files, word processor files, spreadsheet files, etc.) and may include documents (e.g., files) 402J, 402K, and 402L. Interface 400 may include an unassigned document section 412 containing unassigned documents 402M, 402N, 402O, 402P, and 402Q.

[0066] Figure 5A shows user interaction with the exemplary user interface 400 of Figure 4 for assigning documents to document subsets, according to several embodiments of the present disclosure. Specifically, in Figure 5A, the user manually assigns document 402M to document subset 404. More specifically, the user uses an input device (e.g., mouse, trackpad, etc.) to manipulate a cursor and drags document 402M to document subset 404 associated with the paper. The user can manually assign each of documents 402M-402Q to the document subsets 404-410 to which they should be assigned. For example, the user can manually assign document 402N to document subset 408, document 402O to document subset 406, and document 402Q to document subset 410.

[0067] Document 402P represents a document that does not directly correspond to an existing document subset. In some embodiments, a user can create a new document subset using the document subset creation element 415. In some embodiments, a user can associate a specific type of document with the newly created document subset. For example, a user can associate the newly created document subset with a product information document, and then the user can assign document 402P to the newly created document subset. In other examples, a user can first assign document 402P to a newly created document subset, and a computing system implementing interface 400 can create an association between the newly created document subset and the product information document.

[0068] Figure 5B shows user interaction with the exemplary user interface 400 of Figure 4 for assigning documents to document subsets, according to some other embodiments of the present disclosure. Specifically, in Figure 5B, the user provides a selection input to a sort element 416. The sort element 416 causes a computing system implementing the interface 400 to automatically sort the unassigned documents 402M-402Q into existing document subsets 404-410. In some embodiments, the computing system can sort the unassigned documents 402M-402Q by determining the document type for each of the documents. For example, the computing system determines that document 402M is a scholarly paper and therefore should be assigned to document subset 404, which is associated with scholarly papers. In another example, the computing system determines that document 402N is a newspaper clipping and therefore should be assigned to document subset 408, which is associated with newspaper clippings.

[0069] Alternatively, in some embodiments, the computing system can assign unassigned documents 402M-402Q to existing document subsets 404-410 based on some other metrics or heuristics. For example, the computing system can determine the semantic understanding of each document (e.g., whether the "tone" of the document is generally negative or positive) and assign the unassigned documents 402M-402Q based on the determined semantic understanding. In other examples, the computing system can assign one of the unassigned documents 402M-402Q based on multiple decisions. For example, if document subset 406 is for positive newspaper clippings and document subset 408 is for negative newspaper clippings, the computing system can first determine that document 402N is a newspaper clipping, and then determine that newspaper clippings are semantically negative and therefore should be assigned to document subset 408.

[0070] More generally, it should be widely understood that a computing system can assign documents to document subset 408 based on any type or method of criteria (e.g., title, subject, semantic understanding, length, publication date, public accessibility, relevance, file type, etc.). In some embodiments, document subsets and document types may be associated with varying degrees of specificity. For example, a computing system may maintain a relatively strict association between document subset 404 and scholarly article type documents, and a relatively lenient association between document subset 408 and newspaper clipping type documents. Based on these maintained associations, the computing system may decide to refrain from assigning document 402P to document subset 404 (e.g., due to the strict association between the subset and scholarly article type documents) and instead assign document 402P to document subset 408 (e.g., due to the lenient association between the subset and newspaper clipping document type documents).

[0071] Figure 6A shows user interaction with the exemplary user interface 400 of Figure 4 for selecting a document subset from multiple document subsets, according to some embodiments of the present disclosure. Specifically, in some embodiments, the user may provide a cursor input 602 for selecting a document subset 404. Alternatively, in some embodiments, the user may provide a query 604 within a query field 606. The query field 606 allows the user to provide a query to the computer system via the interface 400. Specifically, as shown, the user may provide a query 604 within the query field 606 that asks the computing system, "How much genetic drift has occurred in the cat?" and instructs the computing system to determine this information based on the documents assigned to document subset 404.

[0072] Figure 6B illustrates user interaction with the exemplary user interface 400 of Figure 4 for providing queries via a query field, according to some embodiments of the present disclosure. Specifically, the query field 604 can be used to facilitate interaction between the user and a large language model (e.g., the machine-trained large language model 200 in Figure 2). To follow the illustrated example, the user may provide the query described with respect to Figure 6A. The computing system can process the query 604 to obtain output 608. In some embodiments, the computing system may process the query 604 with a machine-trained embedding model (e.g., described with respect to Figure 3) to identify document chunks (or more) that are semantically similar to the query 604 and return the chunks (or more) as output 608. Alternatively, in some embodiments, the computing system may process the identified document chunks (or more) with a machine-trained large language model (e.g., described with respect to Figure 3) to obtain output 608 containing language output.

[0073] The computing system may provide output 608 for display in the query field 606 of interface 400. The user may provide a second query 610 in the query field 604, and the computing system may process the second query 610 in the same manner to generate a second output 612 for display in the query field 606. In addition, in some embodiments, the computing system may provide attribute information 614 for display in interface 400. The attribute information 614 can identify the document(s) on which the language output 612 is based. In some embodiments, if output 612 contains a particular document chunk(s) from document 402, the attribute information 614 may describe the specific location of the identified document chunk within document 402 from which it originates. For example, the attribute information 614 may be a citation in a specific citation format (e.g., MLA, Chicago Style, Blue Book, etc.) that identifies the location of the document chunk, or it may otherwise describe it. Another example is that attribute information 614, when selected by the user, may include a link that navigates the user to the location within the document from which the document chunk originates.

[0074] Figure 7A illustrates user interaction with a large language model using an exemplary user interface 700 for requesting the model to perform a summarization task, according to several embodiments of the present disclosure. Specifically, the interface in Figure 7A may be presented in response to a user selection of selectable links contained in attribute information 614 as described with respect to Figure 6B. In response to the user selection of selectable links, the interface 700 displays document 402M from document subset 404. Once document 402M is displayed, the interface 700 may facilitate further interaction between the user and the large language model. For example, the user may provide a query 702 requesting the performance of a summarization task. Specifically, the query 702 includes a text query from the user (e.g., "Summarize this") along with an identified (i.e., highlighted) document chunk 704. A computing system may process the query 702 using a machine learning-trained embedding model to obtain the query embedding, and may process the query embedding using a machine learning-trained large language model to obtain language output 706. The language output 706 can summarize the identified document chunk 704.

[0075] A user can provide the computing system with additional queries 708 that instruct it to navigate to different documents. The computing system can process the queries 708 and determine the instructions to navigate to different documents. For example, the computing system can process the queries 708 using a machine learning-based large-scale language model to determine the instructions.

[0076] Figure 7B illustrates additional user interaction with a large language model using an exemplary user interface 700 for requesting the model to perform an opposing viewpoint task, as described in some embodiments of the present disclosure. Specifically, the interface 700 in Figure 7B may include a document 402H in response to the query 708 described in Figure 7A. In some embodiments, in addition to displaying document 402H, the computing system may provide various task elements 710, each corresponding to a specific task that can be performed by the machine-trained large language model. For example, task element 710A corresponds to the performance of a summarization task, as described with respect to Figure 7A. Task element 710B corresponds to the performance of a simplification task. Task element 710C corresponds to the performance of an opposing viewpoint task (i.e., “opposing” opinions). Finally, task element 710D corresponds to a brainstorming task.

[0077] The user can select a task element 710C. Accordingly, the computing system can perform an anti-view task using a machine-learned large-scale language model to generate a language output 712. The language output 712 can describe an anti-view of the opinion expressed by document 402H (or related identified document chunks of document 402H). Following the example shown, the user can select an anti-view element 706C and select a document chunk from document 402H (e.g., highlight it). The computing system can process the document chunk and perform an anti-view task to generate a language output 712 that describes an anti-view of the opinion expressed in the document chunk. In some embodiments, the computing system can determine that text content represents an opinion and, based on that determination, select an anti-view task for the machine-learned large-scale language model.

[0078] Figure 7C illustrates additional user interaction with a large language model using an exemplary user interface 700 for requesting the model to perform a brainstorming task, as described in some embodiments of the present disclosure. Specifically, as shown in Figure 7C, the user can select a brainstorming task 706D. In some embodiments, the computing system can query which document subset to perform the brainstorming task on. For example, the user can specify that they want to perform the brainstorm on document subset 2 (e.g., document subset 406 associated with patent documents). Accordingly, the computing system can generate multiple language outputs 714 and display the language outputs 714 to the user within interface 700. Each language output 714 may be generated iteratively based on different identified documents, document chunks, combinations of identified document chunks, etc.

[0079] Figure 7D illustrates additional user interaction with a large language model using an exemplary user interface 700 for requesting the model to perform a simplification task, as described in some embodiments of the present disclosure. Specifically, in some embodiments, rather than selecting a task element, the computing system can automatically decide to perform a particular task using a machine-trained large language model. For example, the computing system can determine a complexity metric (e.g., a word frequency-inverse document frequency (TF-IDF) metric, a metric generated using a complexity classification model) that describes the degree of complexity associated with identified chunks of document 402C. Based on the determination that the complexity metric is greater than a threshold for the degree of complexity, the computing system can select a simplification task from among several tasks for the machine-trained large language model. The computing system can process the identified document chunks from document 402C using the machine-trained large language model to generate a language output 716, which is a simplified language output that simplifies the identified document chunks. In some embodiments, the computing system can replace the language output with a simplified language output within the user interface.

[0080] Figure 8 shows various interface layouts that can implement the interfaces in the previous figures according to some embodiments of this disclosure. More generally, it should be noted that the interfaces described with respect to Figures 4–7D are illustrated solely to demonstrate how they can facilitate user interaction with large language models. However, such interfaces can be implemented using any type or method of layout, design, interface elements, application(s), etc.

[0081] As a specific example, Figure 8 shows an interface for a web application in which a user can input data into a text editing interface 802. For example, the text editing interface 802 could be an interface for a document processing application that allows a user to input text content into the document processing application. In other examples, the text editing interface 802 could be an interface that allows a user to input text into a spreadsheet application, slide deck application, calendar application, instant messaging application, database application, social media application, game application, etc.

[0082] In some embodiments, the interfaces in Figures 4–7D can be located within some or all of the interface locations 804, 806, 808, 810, and 812. For example, interface 400 in Figures 4–6B can be located within interface location 806 (for example, to allow users to manipulate a subset of documents by adding, deleting, or rearranging them). Interface 700 in Figures 7A–7D may be implemented in any of the interface locations 804, 808, 810, and 812, or it may be distributed among multiple interface locations.

[0083] As a specific example, query field 606 in Figure 6A can be implemented at interface location 810. Language output from a machine learning-trained large-scale language model can be presented and stored / indexed at interface location 808. Document chunks identified from documents managed at interface location 806 can be retrieved and displayed to the user within interface location 804. Additional settings for each of these interface embodiments can be modified within a separate interface (e.g., a tab separate from the current interface) accessible from interface location 814.

[0084] Accordingly, it should be understood that embodiments of this disclosure are not limited to the specific interface embodiments shown herein. Rather, embodiments described herein that facilitate semantic exploration of a specified subset of a document, improved explainability of large language model interactions, selection of specific language tasks to improve user interaction with large language models, and / or dynamic selection of tasks for large language models can be implemented using user interfaces of any type or method.

[0085] Exemplary Method Figure 9 shows a flowchart of an exemplary method 900 that performs a semantic search of a specified subset of multiple documents, according to an exemplary embodiment of the present disclosure. While Figure 9 shows steps performed in a particular order for illustrative and explanatory purposes, the methods of the present disclosure are not limited to the order or arrangement shown. Various steps of method 900 can be omitted, rearranged, combined, and / or adapted in various ways without departing from the scope of the present disclosure.

[0086] In 902, a computing system including one or more computing devices can receive data indicating a text query.

[0087] In version 904, the computing system can use a machine learning-based embedding generation model to generate text embeddings for text queries.

[0088] In version 906, the computing system can access multiple chunk embeddings, each generated by a machine learning-based embedding generation model for multiple document chunks of multiple documents. Multiple documents can be organized into multiple document subsets.

[0089] In 908, the computing system can obtain data indicating one or more selected document subsets from a plurality of document subsets. In some embodiments, one or more selected document subsets are specified by the user. In some embodiments, at least some of the documents included in one or more selected document subsets include documents provided by the user. In some embodiments, at least some of the documents included in one or more selected document subsets include books, product manuals, legal opinions, scholarly articles, proprietary data files, patent documents, or any other type or method of document (e.g., web pages, emails, forum posts, social media posts, videos, images, etc.).

[0090] In 910, the computing system may perform a similarity search for text embeddings only with respect to chunk embeddings associated with document chunks contained in one or more selected subsets of documents, and the similarity search identifies one or more chunk embeddings as semantically similar to the text query.

[0091] In 912, the computing system may provide for displaying within a user interface one or more of a plurality of document chunks corresponding to one or more of the chunk embeddings identified by similarity search. In some embodiments, the user interface includes a text editing interface associated with a document processing application. In some embodiments, the user interface includes a primary text editing field that allows a user of the user interface to generate a set of text, and a text query that includes at least a portion of the set of text generated by the user through interaction with the primary text editing field. In some embodiments, the user interface includes a primary text editing field that allows a user to generate a set of text, and a query field separate from the primary text editing field that allows the user to enter a text query separately from the set of text.

[0092] In some embodiments, the user interface includes a document subset selection tool that allows the user to provide user input for selecting one or more selected document subsets from a plurality of document subsets. In some embodiments, the document subset selection tool provides a graphical representation of the plurality of document subsets. In some embodiments, the document subset selection tool allows the user to apply a set of filter logic to the plurality of document subsets, thereby selecting one or more selected document subsets from the plurality of document subsets.

[0093] In some embodiments, the computing system retrieves multiple documents, parses the multiple documents into multiple document chunks, and generates multiple chunk embeddings using a machine learning-based embedding generation model.

[0094] Figure 10 shows a flowchart of an exemplary method 1000 for performing an improved explainability of large-scale language model interaction, according to an exemplary embodiment of the present disclosure. While Figure 10 shows steps performed in a specific order for illustrative and explanatory purposes, the methods of the present disclosure are not limited to the order or arrangement shown. Various steps of method 1000 can be omitted, rearranged, combined, and / or adapted in various ways without departing from the scope of the present disclosure.

[0095] In steps 1002-1004, the computing system can receive data representing text queries and, using a machine learning-based embedding generation model, can generate text embeddings for the query text, as illustrated in Figure 9.

[0096] In 1006, the computing system can perform a similarity search for text embeddings with respect to multiple chunk embeddings, each generated by a machine learning-trained embedding generation model for multiple document chunks of multiple documents. The similarity search identifies one or more identified document chunks from the multiple document chunks as semantically similar to the text query.

[0097] In some embodiments, before performing a similarity search for text embeddings on multiple chunk embeddings generated by a machine learning-based embedding generation model for multiple document chunks of multiple documents, the computing system can access multiple chunk embeddings generated by a machine learning-based embedding generation model for multiple document chunks of multiple documents. Multiple documents are organized into multiple document subsets. In some embodiments, the computing system can retrieve data that represents one or more selected document subsets from among the multiple document subsets.

[0098] In some embodiments, performing a similarity search for text embeddings may include performing a similarity search for text embeddings only with respect to chunk embeddings associated with document chunks contained within one or more selected document subsets. The similarity search identifies one or more identified document chunks from among multiple document chunks contained within one or more selected document subsets as semantically similar to the text query.

[0099] In step 1008, the computing system generates a prompt containing one or more identified document chunks.

[0100] In step 1010, the computing system provides prompts for processing by the machine learning-trained large-scale language model, which are then used as input to the machine learning-trained large-scale language model.

[0101] At 10¹², the computing system receives language output generated by a machine learning-trained large-scale language model based on the processing of prompts.

[0102] In 1014, the computing system provides language output as output. In some embodiments, providing language output as output includes the computing system providing language output for display within a user interface associated with a document processing application. In some embodiments, providing language output for display within a user interface further includes the computing system providing attribute information for display within the user interface. The attribute information identifies a document among one or more document subsets containing an identified document chunk among one or more identified document chunks. In some embodiments, the attribute information describes the location of the identified document chunk within the document. In some embodiments, the user interface includes a primary text editing field that allows a user of the user interface to generate a set of text. A text query includes at least a portion of the set of text generated by the user through interaction with the primary text editing field. In some embodiments, one or more selected document subsets are specified by the user.

[0103] In some embodiments, the computing system may receive data indicating a second text query that includes at least a portion of a second set of text generated by the user through interaction with a primary text editing field. The second set of text responds to language output.

[0104] In some embodiments, the computing system may use a machine learning-based embedding generation model to further generate text embeddings for a second text query. The computing system may perform a second similarity search for the second text embeddings with respect only to chunk embeddings associated with document chunks contained in one or more second document subsets of multiple document subsets. The second similarity search identifies one or more second identified document chunks contained in one or more second document subsets as semantically similar to the second text query. The computing system may generate a second prompt containing one or more second identified document chunks. The computing system may provide the second prompt as input to a machine learning-based large-scale language model for processing by the machine learning-based large-scale language model. The computing system may receive a second language output generated by the second machine learning-based large-scale language model based on the processing of the prompt. The computing system may provide the second language output for display within a user interface associated with a document processing application.

[0105] In some embodiments, before performing a second similarity search for a second text embedding with respect only to chunk embeddings associated with document chunks contained in one or more second document subsets, the computing system may obtain information indicating the user's selection of one or more second document subsets from multiple document subsets. In some embodiments, the user interface includes a document subset selection tool that allows the user to provide user input for selecting one or more selected document subsets from multiple document subsets. In some embodiments, the document subset selection tool provides a graphical representation of the multiple document subsets. In some embodiments, the document subset selection tool allows the user to apply a set of filter logic to the multiple document subsets. The application of the filter logic results in the selection of one or more selected document subsets from the multiple document subsets.

[0106] In some embodiments, the computing system can select one or more second document subsets from a plurality of document subsets based at least partially on a user-generated set of second texts, before performing a second similarity search for second text embeddings with respect only to chunk embeddings associated with document chunks contained in one or more second document subsets.

[0107] Figure 11 shows a flowchart of an exemplary method 1100 for performing the facilitation of selecting specific language tasks to enhance user interaction with a large language model, according to an exemplary embodiment of the present disclosure. While Figure 11 shows the steps performed in a particular order for illustrative and explanatory purposes, the methods of the present disclosure are not limited to the order or arrangement shown. Various steps of method 1100 can be omitted, rearranged, combined, and / or adapted in various ways without departing from the scope of the present disclosure.

[0108] In 1102, the computing system can obtain user interaction information. User interaction information can include (a) a text query comprising at least a portion of a set of text generated by the user through interaction with a text editing field of the user interface, wherein the user interface comprises a text editing field and a plurality of selectable task elements, each associated with a plurality of tasks for a machine learning-trained large-scale language model, and (b) selected task elements selected by the user from the plurality of selectable text elements.

[0109] In 1104, the computing system can use a machine learning-based embedding generation model to generate text embeddings for text queries.

[0110] In step 1106, the computing system performs a similarity search for text embeddings with respect to multiple chunk embeddings, each generated by a machine learning-trained embedding generation model for multiple document chunks of multiple documents. The similarity search identifies one or more identified document chunks from the multiple document chunks as semantically similar to the text query.

[0111] In some embodiments, before performing a similarity search for text embeddings on multiple chunk embeddings generated by a machine learning-based embedding generation model for multiple document chunks of multiple documents, the computing system can access multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, and the multiple documents are organized into multiple document subsets. The computing system can obtain data indicating one or more selected document subsets from the multiple document subsets. In some embodiments, obtaining data indicating one or more selected document subsets may include obtaining data indicating a selection of one or more selected document subsets from the multiple document subsets through user interaction with a user interface.

[0112] In some embodiments, performing a similarity search for text embeddings means performing a similarity search for text embeddings only with respect to chunk embeddings associated with document chunks contained in one or more selected document subsets, and the similarity search may include performing the search to identify one or more identified document chunks from a plurality of document chunks contained in one or more selected document subsets as semantically similar to the text query.

[0113] In 1108, the computing system can process prompts based on one or more identified document chunks using a machine learning-trained large-scale language model to perform a task among several tasks associated with a selected task element.

[0114] In 1110, the computing system can obtain language output generated by a machine learning-trained large-scale language model based on the processing of prompts.

[0115] In some embodiments, the computing system may provide language output for display within a user interface associated with a document processing application. In some embodiments, providing language output for display within a user interface may further include providing attribute information for display within the user interface, the attribute information identifying a document among one or more document subsets containing an identified document chunk among one or more identified document chunks.

[0116] In some embodiments, a text query may include a second text query received following a previous text query, the second text query responding to the previous language output based on the previous text query.

[0117] In some embodiments, a selected task element is associated with an idea expansion task among multiple tasks, and one or more identified document chunks comprises multiple identified document chunks. Processing prompts based on one or more identified document chunks using a machine learning-trained large language model to perform the task may, for multiple iterations, involve the computing system processing new prompts to obtain updated language output, where the new prompts are based on one or more of (a) a subset of identified document chunks among the multiple identified document chunks, or (b) previously updated language output.

[0118] In some embodiments, selected task elements are associated with a task summarizing multiple tasks. Processing prompts based on one or more identified document chunks using a machine learning-trained large-scale language model to perform a task may include processing prompts based on one or more identified document chunks using a machine learning-trained large-scale language model to obtain language output, which includes summaries of one or more identified document chunks.

[0119] In some embodiments, selected task elements are associated with simplification tasks of multiple tasks. Processing prompts based on one or more identified document chunks using a machine learning-trained large-scale language model to perform a task may include processing prompts based on one or more identified document chunks using a machine learning-trained large-scale language model to obtain language output. A computing system may use a machine learning-trained large-scale language model to generate a simplified language output that describes a simplified representation of the language output.

[0120] In some embodiments, selected task elements are associated with opposite-view tasks of multiple tasks. Processing prompts based on one or more identified document chunks using a machine-trained large-scale language model to perform a task may include processing prompts based on one or more identified document chunks using a machine-trained large-scale language model to obtain language output. The language output describes the viewpoint. The computing system may use the machine-trained large-scale language model to generate a second language output that describes a second viewpoint opposite to the output of the viewpoint.

[0121] Figure 12 shows a flowchart of exemplary Method 1200 for performing dynamic selection of tasks for a large language model according to exemplary embodiments of the present disclosure. Figure 12 shows the steps performed in a particular order for illustrative and explanatory purposes, but the methods of the present disclosure are not limited to the order or arrangement shown. Various steps of Method 1200 can be omitted, rearranged, combined, and / or adapted in various ways without departing from the scope of the present disclosure.

[0122] In 1202, the computing system can obtain user interaction information indicating a text query that includes at least a portion of a set of text generated by the user, through interaction with a text editing field of the user interface.

[0123] In version 1204, the computing system can use a machine learning-based embedding generation model to generate text embeddings for text queries.

[0124] In version 1206, the computing system can perform a similarity search for text embeddings with respect to multiple chunk embeddings, each generated by a machine learning-trained embedding generation model for multiple document chunks of multiple documents. The similarity search identifies one or more identified document chunks from the multiple document chunks as semantically similar to the text query.

[0125] In 1208, the computing system can select a first task from a set of tasks for a machine learning-trained large-scale language model based at least partially on a text query or at least one of one or more identified document chunks.

[0126] In 1210, the computing system can process prompts based on one or more identified document chunks using a machine learning-trained large-scale language model to perform a first task among several tasks associated with a selected task element.

[0127] In 1212, the computing system can obtain language output generated by a machine learning-trained large-scale language model based on the processing of prompts.

[0128] Additional disclosures The technologies described herein refer to servers, databases, software applications, and other computer-based systems, as well as actions performed on such systems and information transmitted to and from such systems. The inherent flexibility of computer-based systems allows for a wide variety of feasible configurations, combinations, and divisions of tasks and functions between components. For example, the processes described herein can be performed using a single device or component, or multiple devices or components working together. Databases and applications can be run on a single system or distributed across multiple systems. Distributed components can operate sequentially or in parallel.

[0129] While the subject matter has been described in detail with respect to various specific exemplary embodiments, each example is provided for illustrative purposes only and does not limit the disclosure. Those skilled in the art will readily be able to create modifications, variations, and equivalents to such embodiments, understanding the foregoing. Therefore, the disclosure does not exclude the inclusion of such modifications, variations, and / or additions to the subject matter, which will be readily apparent to those skilled in the art. For example, features illustrated or described as part of one embodiment may be used together with other embodiments to create yet another embodiment. Therefore, the disclosure is intended to cover such modifications, variations, and equivalents.

[0130] Embodiment The following embodiments include some of the many embodiments described herein. While the processes in the drawings may illustrate a specific sequence of operations performed by a particular embodiment of this disclosure, it should be understood that such a sequence is illustrative (for example, alternative embodiments may perform operations in a different order, combine certain operations, or overlap certain operations).

[0131] Embodiment 1: A computer-implemented method for semantic search of a specified subset of multiple documents, A computing system including one or more computing devices receives data indicating a text query, The computing system generates text embeddings for the text query using a machine learning-based embedding generation model, The computing system accesses multiple chunk embeddings generated by the machine learning-prepared embedding generation model for multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets, and accesses them. The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets, - The computing system performs a similarity search for the text embeddings with respect only to chunk embeddings associated with document chunks contained in the one or more selected subsets of documents, wherein the similarity search identifies one or more chunk embeddings as semantically similar to the text query. - To provide the computing system with one or more of the document chunks corresponding to one or more of the chunk embeddings identified by the similarity search, for display within the user interface. A method of implementation in a computer, including

[0132] Embodiment 2: A method implemented on a computer according to Embodiment 1, wherein the user interface includes a text editing interface associated with a document processing application.

[0133] Embodiment 3: The user interface includes a primary text editing field that allows the user of the user interface to generate a set of text. The text query includes at least a portion of the set of text generated by the user through interaction with the primary text editing field. A method implemented in a computer according to Embodiment 2.

[0134] Embodiment 4: The user interface is, • A primary text editing field that allows the user to generate a set of text, A query field separate from the primary text editing field, which allows the user to enter the text query separately from the set of text, A method implemented in a computer according to Embodiment 2, including the method described in Embodiment 2.

[0135] Embodiment 5: The one or more selected subsets of documents are implemented on a computer according to any one of Embodiments 1 to 4, as specified by the user.

[0136] Embodiment 6: A computer implementation method according to Embodiment 5, wherein the user interface includes a document subset selection tool that enables the user to provide user input for selecting one or more selected document subsets from the plurality of document subsets.

[0137] Embodiment 7: The document subset selection tool is a computer-based implementation of Embodiment 6, which provides a graphical representation of the plurality of document subsets.

[0138] Embodiment 8: A computer-implemented method according to Embodiment 6 or 7, wherein the document subset selection tool enables the user to apply a set of filter logic to the plurality of document subsets, and the application of the filter logic selects one or more selected document subsets from the plurality of document subsets.

[0139] Embodiment 9: A computer implementation according to any one of Embodiments 1 to 8, wherein at least some of the documents included in the one or more selected subsets of documents include documents provided by the user.

[0140] Embodiment 10: At least some of the documents included in the one or more selected document subsets are Books, Product manual, ·Legal opinion; • Academic papers, • Occupied data file, or • Patent Documents A method implemented in a computer according to any one of embodiments 1 to 9, including the following:

[0141] Embodiment 11: The computing system retrieves the multiple documents, The computing system parses the multiple documents into the multiple document chunks, The computing system generates the multiple chunk embeddings using the machine learning-prepared embedding generation model, A computer implementation method according to any one of embodiments 1 to 10, further including the following:

[0142] Embodiment 12: A computer system for semantic search of a specified subset of multiple documents, • One or more processors, • One or more non-temporary computer-readable media, The one or more non-temporary computer-readable media include, o Multiple chunk embeddings generated by a machine learning-based embedding generation model for multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets, and o Instructions that cause the computer system to perform an action when executed by one or more processors, The data is stored collectively, and the operation described above is: • Receiving data that indicates a text query, • Using the machine learning-based embedding generation model, generate text embeddings for the text query. - Obtaining data that indicates one or more selected document subsets from the aforementioned plurality of document subsets, - Performing a similarity search for text embeddings with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, wherein the similarity search identifies one or more chunk embeddings as semantically similar to the text query. - To provide one or more of the multiple document chunks corresponding to one or more of the chunk embeddings identified by the similarity search for display within the user interface, including, Computer system.

[0143] Embodiment 13: The computer system according to Embodiment 12, wherein the user interface includes a text editing interface associated with a document processing application.

[0144] Embodiment 14: The user interface includes a primary text editing field that allows the user to generate a set of text. The text query includes at least a portion of the set of text generated by the user through interaction with the primary text editing field. The computer system described in Embodiment 13.

[0145] Embodiment 15: The user interface is, • A primary text editing field that allows the user to generate a set of text, A query field separate from the primary text editing field, which allows the user to enter the text query separately from the set of text, A computer system according to embodiment 13, including the above.

[0146] Embodiment 16: The computer system according to any one of Embodiments 12 to 15, wherein the one or more selected subsets of documents are specified by the user.

[0147] Embodiment 17: The computer system according to Embodiment 16, wherein the user interface includes a document subset selection tool that enables the user to provide user input for selecting one or more selected document subsets from the plurality of document subsets.

[0148] Embodiment 18: The computer system according to Embodiment 17, wherein the document subset selection tool provides a graphical display of the plurality of document subsets.

[0149] Embodiment 19: The computer system according to Embodiment 17 or 18, wherein the document subset selection tool allows the user to apply a set of filter logic to the plurality of document subsets, and the application of the filter logic selects one or more selected document subsets from the plurality of document subsets.

[0150] Embodiment 20: The above operation is, • Obtaining the aforementioned multiple documents, - Parsing the aforementioned multiple documents into the aforementioned multiple document chunks, • Using the machine learning-prepared embedding generation model, generate the multiple chunk embeddings, A computer system according to any one of embodiments 12 to 19, further including the above.

[0151] Embodiment 21: A computer-implemented method for large-scale language model interaction with improved explainability, A computing system including one or more computing devices receives data indicating a text query, The computing system generates text embeddings for the text query using a machine learning-based embedding generation model, - The computing system performs a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. The computing system generates a prompt containing the one or more identified document chunks, The computing system provides the prompts to be processed by the machine learning-trained large-scale language model as input to the machine learning-trained large-scale language model. The computing system receives language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, The computing system provides the language output as output, A method of implementation in a computer, including

[0152] Embodiment 22: The computer implementation of Embodiment 21, wherein, before performing the similarity search for the text embeddings with respect to the chunk embeddings generated by the machine learning-based embedding-generating model for each of the document chunks of the plurality of documents, the method includes accessing the chunk embeddings generated by the machine learning-based embedding-generating model for each of the document chunks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets.

[0153] Embodiment 23: The computer implementation of Embodiment 22, wherein accessing the plurality of chunk embeddings generated by the machine learning-prepared embedding generation model for each of the plurality of document chunks of the plurality of documents further comprises the computing system obtaining data representing one or more selected document subsets of the plurality of document subsets.

[0154] Embodiment 24: A computer-implemented method according to Embodiment 23, wherein performing the similarity search for text embeddings is performed by the computing system with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, the similarity search includes performing the same search as semantically similar to the text query, one or more identified document chunks from the plurality of document chunks contained in the one or more selected document subsets.

[0155] Embodiment 25: A method implemented in the computer according to Embodiment 24, wherein providing the language output as output includes the computing system providing the language output for display within a user interface associated with a document processing application.

[0156] Embodiment 26: A method implemented in a computer according to Embodiment 25, wherein providing the language output for display within the user interface comprises providing attribute information for display within the user interface by the computing system, wherein the attribute information identifies a document among one or more selected document subsets, which includes an identified document chunk among one or more identified document chunks.

[0157] Embodiment 27: A method implemented on a computer according to Embodiment 26, wherein the attribute information describes the location of the identified document chunk within the document. Embodiment 28: A computer implementation of Embodiment 25, wherein the user interface includes a primary text editing field that enables a user of the user interface to generate a set of text, and the text query includes at least a portion of the set of text generated by the user through interaction with the primary text editing field.

[0158] Embodiment 29: The one or more selected document subsets are implemented on the computer according to Embodiment 28, as specified by the user.

[0159] Embodiment 30: The method, implemented on a computer according to any one of Embodiments 28 to 29, further comprising the computing system receiving data indicating a second text query which includes at least a portion of a second set of text generated by the user through interaction with the primary text editing field, the second set of text which responds to the language output.

[0160] Embodiment 31: The method described above is The computing system generates a second text embedding for the second text query using the machine learning-prepared embedding generation model, - The computing system performs a second similarity search for the second text embedding with respect only to chunk embeddings associated with document chunks contained in one or more second document subsets of the plurality of document subsets, wherein the second similarity search identifies one or more second identified document chunks contained in the one or more second document subsets as semantically similar to the second text query. The computing system generates a second prompt containing one or more second identified document chunks, The computing system provides the second prompt for processing by the machine learning-prepared large-scale language model as input to the machine learning-prepared large-scale language model, The computing system receives a second language output generated by the machine learning-prepared large-scale language model based on the processing of the second prompt. The computing system provides a second language output for display within a user interface associated with a document processing application. A computer implementation method according to embodiment 30, further including the following:

[0161] Embodiment 32: A computer-implemented method according to Embodiment 31, wherein, before performing the second similarity search for the second text embedding with respect only to the chunk embedding associated with the document chunks contained in the one or more second document subsets, the method includes the computing system obtaining information indicating the user's selection of one or more second document subsets from the plurality of document subsets.

[0162] Embodiment 33: A computer implementation method according to Embodiment 32, wherein the user interface includes a document subset selection tool that enables the user to provide user input for selecting one or more selected document subsets from the plurality of document subsets.

[0163] Embodiment 34: The document subset selection tool is a computer-based implementation of the embodiment 33, which provides a graphical representation of the plurality of document subsets.

[0164] Embodiment 35: A computer-implemented method according to Embodiment 33 or 34, wherein the document subset selection tool enables the user to apply a set of filter logic to the plurality of document subsets, and the application of the filter logic selects one or more selected document subsets from the plurality of document subsets.

[0165] Embodiment 36: A computer-implemented method according to Embodiment 31, wherein, before performing the second similarity search for the second text embedding with respect only to the chunk embedding associated with the document chunk contained in the one or more second document subsets, the method includes the computing system selecting the one or more second document subsets from the plurality of document subsets based at least in part on the set of the second text generated by the user.

[0166] Embodiment 37: A computer system for large-scale language model interaction with improved explainability, • One or more processors, The system includes one or more non-temporary computer-readable media that, when executed by the one or more processors, collectively store instructions that cause the computing system to perform an operation, and the operation is o Receiving data that indicates a text query, o Using a machine learning-based embedding generation model, generate text embeddings for the text query, o Performing a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-prepared embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query, o Generate a prompt containing one or more identified document chunks, o Provide the prompts to be processed by the machine learning-prepared large-scale language model as input to the machine learning-prepared large-scale language model, o Receiving language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, To provide the language output as output, A computer system, including a computer system.

[0167] Embodiment 38: The computer system according to Embodiment 37, wherein, before performing the similarity search for the text embeddings with respect to the chunk embeddings generated by the machine learning-based embedding-generating model for each of the document chunks of the plurality of documents, the operation includes accessing the chunk embeddings generated by the machine learning-based embedding-generating model for each of the document chunks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets.

[0168] Embodiment 39: The computer system according to Embodiment 38, wherein accessing the plurality of chunk embeddings generated by the machine learning-prepared embedding generation model for each of the plurality of document chunks of the plurality of documents further comprises obtaining data representing one or more selected document subsets of the plurality of document subsets.

[0169] Embodiment 40: One or more non-temporary computer-readable media that, when executed by one or more processors of a computing system, store instructions causing the computing system to perform an operation, wherein the operation is • Receiving data that indicates a text query, • Using a machine learning-based embedding generation model, generate text embeddings for the text query. - Performing a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-prepared embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query, • To generate a prompt containing one or more identified document chunks, - Providing the aforementioned prompts as input to a machine learning-prepared large-scale language model for processing by the machine learning-prepared large-scale language model, - Receiving language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, • Provide the aforementioned language output as output, One or more non-temporary computer-readable media, including [the specified text].

[0170] Embodiment 41: A computer-implemented method for facilitating the selection of specific language tasks in order to improve user interaction with a large-scale language model, • A computing system including one or more computing devices, A text query comprising at least a portion of a set of text generated by a user through interaction with a text editing field of a user interface, wherein the user interface comprises the text editing field and a plurality of selectable task elements, each associated with a plurality of tasks for a machine learning-trained large-scale language model, o Selected task element selected by the user from the plurality of selectable task elements, Obtaining user interaction information that indicates this, The computing system generates text embeddings for the text query using a machine learning-based embedding generation model, - The computing system performs a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. The computing system processes prompts based on one or more identified document chunks using the machine learning-prepared large-scale language model in order to perform the task among the multiple tasks associated with the selected task element. The computing system obtains language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, A method of implementation in a computer, including

[0171] Embodiment 42: The computer implementation of Embodiment 41, wherein, before performing the similarity search for the text embeddings with respect to the chunk embeddings generated by the machine learning-based embedding-generating model for each of the document chunks of the plurality of documents, the method includes accessing the chunk embeddings generated by the machine learning-based embedding-generating model for each of the document chunks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets, and the computing system obtains data indicating one or more selected document subsets from the plurality of document subsets.

[0172] Embodiment 43: The computer implementation of Embodiment 42, wherein obtaining the data indicating the one or more selected document subsets is performed by the computing system, through the user's interaction with the user interface, to obtain data indicating the selection of one or more selected document subsets from the plurality of document subsets.

[0173] Embodiment 44: A computer-implemented method according to any one of Embodiments 42 to 43, wherein performing the similarity search for text embeddings is performed by the computing system with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, the similarity search includes performing the same search as identifying one or more identified document chunks from the plurality of document chunks contained in the one or more selected document subsets as semantically similar to the text query.

[0174] Embodiment 45: A computer-implemented method according to Embodiment 44, further comprising providing the language output for display within a user interface associated with a document processing application by the computing system.

[0175] Embodiment 46: A method implemented in a computer according to Embodiment 45, wherein providing the language output for display within the user interface comprises providing attribute information for display within the user interface by the computing system, wherein the attribute information identifies a document among one or more selected document subsets, which includes an identified document chunk among one or more identified document chunks.

[0176] Embodiment 47: A computer implementation method according to any one of Embodiments 41 to 46, wherein the text query includes a second text query received following a previous text query, and the second text query responds to a previous language output based on the previous text query.

[0177] Embodiment 48: A computer-implemented method according to any one of Embodiments 41 to 47, wherein the selected task element is associated with an idea expansion task among the plurality of tasks, the one or more identified document chunks comprises a plurality of identified document chunks, and processing the prompts based on the one or more identified document chunks using the machine-learned large language model to perform the task comprises, for a plurality of iterations, processing new prompts by the computing system to obtain updated language output, the new prompts being based on one or more of (a) a subset of identified document chunks among the plurality of identified document chunks, or (b) previously updated language output.

[0178] Embodiment 49: A method implemented on a computer according to any one of Embodiments 41 to 47, wherein the selected task element is associated with a summary task of the plurality of tasks, and processing the prompt based on the one or more identified document chunks using the machine-learned large language model in order to perform the task, includes processing the prompt based on the one or more identified document chunks using the machine-learned large language model by the computing system in order to obtain the language output, the language output including a summary of the one or more identified document chunks.

[0179] Embodiment 50: The selected task element is associated with a task that simplifies the plurality of tasks, and in order to perform the task, the prompt is processed based on the one or more identified document chunks using the machine learning-trained large language model, To obtain the language output, the computing system processes the prompt based on one or more identified document chunks using the machine learning-prepared large-scale language model, The computing system uses the machine learning-prepared large-scale language model to generate a simplified language output that describes a simplified representation of the language output, A method implemented in a computer according to any one of embodiments 41 to 47, including the following:

[0180] Embodiment 51: The selected task element is associated with an opposite view task of the plurality of tasks, and in order to perform the task, the prompt is processed based on one or more identified document chunks using the machine learning-trained large language model, - In order to obtain the language output describing the viewpoint, the computing system processes the prompt based on one or more identified document chunks using the machine learning-prepared large-scale language model, The computing system uses the machine learning-prepared large-scale language model to generate a second language output that describes a second perspective opposite to the output of the aforementioned perspective. A method implemented in a computer according to any one of embodiments 41 to 47, including the following:

[0181] Embodiment 52: A computer system for facilitating the selection of specific language tasks in order to improve user interaction with a large-scale language model, • One or more processors, The system includes one or more non-temporary computer-readable media that, when executed by the one or more processors, collectively store instructions that cause the computing system to perform an operation, and the operation is o User interaction information, A text query comprising at least a portion of a set of text generated by a user through interaction with a text editing field of a user interface, wherein the user interface comprises the text editing field and a plurality of selectable task elements, each associated with a plurality of tasks for a machine learning-trained large-scale language model. The selected task element selected by the user from the multiple selectable task elements, Obtaining user interaction information that indicates this, o Using a machine learning-based embedding generation model, generate text embeddings for the text query, o Performing a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-prepared embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query, o Processing prompts based on one or more identified document chunks using the machine learning-trained large-scale language model in order to perform the task among the multiple tasks associated with the selected task element, o Obtain the language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, including, Computer system.

[0182] Embodiment 53: Before performing the similarity search for the text embeddings with respect to the chunk embeddings generated by the machine learning-trained embedding generation model for each of the chunk embeddings of the chunk - Accessing the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for each of the multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets, and accessing them. - Obtaining data that indicates one or more selected document subsets from the aforementioned plurality of document subsets, A computer system according to embodiment 52, including the above.

[0183] Embodiment 54: The computer system according to Embodiment 53, wherein obtaining the data indicating the one or more selected document subsets includes obtaining data indicating the selection of one or more selected document subsets from the plurality of document subsets through interaction by the user with the user interface.

[0184] Embodiment 55: The computer system according to Embodiment 53, wherein performing the similarity search for text embeddings is performed with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, the similarity search includes performing the search to identify one or more identified document chunks from the plurality of document chunks contained in the one or more selected document subsets as semantically similar to the text query.

[0185] Embodiment 56: The computer system according to Embodiment 55, wherein the operation further comprises providing the language output for display within a user interface associated with a document processing application, and providing the language output for display within the user interface further comprises providing attribute information for display within the user interface, the attribute information identifies a document among the one or more selected subsets of documents, which includes an identified document chunk among the one or more identified document chunks.

[0186] Embodiment 57: A computer system according to any one of Embodiments 52 to 56, wherein the text query includes a second text query received following a previous text query, and the second text query responds to a previous language output based on the previous text query.

[0187] Embodiment 58: The computer system according to any one of Embodiments 52 to 56, wherein the selected task element is associated with an idea expansion task among the plurality of tasks, the one or more identified document chunks comprises a plurality of identified document chunks, and processing the prompts based on the one or more identified document chunks using the machine-learned large language model to perform the task comprises processing the prompts based on different subsets of identified document chunks among the plurality of identified document chunks for a plurality of iterations to obtain each of a plurality of outputs, the language output comprising at least some of the plurality of outputs.

[0188] Embodiment 59: The selected task element is associated with a summarization task of the plurality of tasks, and in order to perform the task, the prompt is processed based on the one or more identified document chunks using the machine learning-trained large language model, - To obtain the language output, the prompt is processed based on one or more identified document chunks using the machine learning-prepared large-scale language model, • To generate a summary of the language output, the machine learning-prepared large-scale language model is used, A computer system according to any one of embodiments 52 to 56, including the following:

[0189] Embodiment 60: One or more non-temporary computer-readable media that, when executed by one or more processors of a computing system, store instructions that cause the computing system to perform an operation, wherein the operation is • User interaction information, A text query comprising at least a portion of a set of text generated by a user through interaction with a text editing field of a user interface, wherein the user interface comprises the text editing field and a plurality of selectable task elements, each associated with a plurality of tasks for a machine learning-trained large-scale language model, o Selected task element selected by the user from the plurality of selectable task elements, Obtaining user interaction information that indicates this, • Using a machine learning-based embedding generation model, generate text embeddings for the text query. - Performing a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-prepared embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query, - To perform the task among the multiple tasks associated with the selected task element, the machine learning-trained large-scale language model is used to process prompts based on one or more identified document chunks, - Obtaining language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, including, One or more non-temporary computer-readable media.

[0190] Embodiment 61: A computer-implemented method for dynamic task selection for a large-scale language model, A computing system including one or more computing devices obtains user interaction information indicating a text query that includes at least a portion of a set of text generated by the user, through interaction with a text editing field of a user interface. The computing system generates text embeddings for the text query using a machine learning-based embedding generation model, - The computing system performs a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. The computing system selects a first task from a plurality of tasks for a machine learning-trained large-scale language model, at least partially based on the text query or at least one of the one or more identified document chunks. - In order to perform the first of the multiple tasks, the computing system processes prompts based on one or more identified document chunks using the machine learning-prepared large-scale language model, The computing system obtains language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, A method of implementation in a computer, including

[0191] Embodiment 62: Before performing the similarity search for the text embeddings with respect to the chunk embeddings generated by the machine learning-trained embedding generation model for each of the chunk embeddings of the chunk The computing system accesses the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for each of the multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets, and accesses them. The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets, A method implemented in a computer according to Embodiment 61, including the following:

[0192] Embodiment 63: The computer implementation of Embodiment 62, wherein obtaining the data indicating the one or more selected document subsets is performed by the computing system, through the user's interaction with the user interface, to obtain data indicating the selection of one or more selected document subsets from the plurality of document subsets.

[0193] Embodiment 64: A computer-implemented method according to any one of Embodiments 62 to 63, wherein performing the similarity search for text embeddings is performed by the computing system with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, the similarity search includes performing the same search as identifying one or more identified document chunks from the plurality of document chunks contained in the one or more selected document subsets as semantically similar to the text query.

[0194] Embodiment 65: A computer-implemented method according to Embodiment 64, further comprising the computing system providing the language output for display within a user interface associated with a document processing application.

[0195] Embodiment 66: A computer-implemented method according to Embodiment 65, wherein providing the language output for display within the user interface comprises providing attribute information for display within the user interface by the computing system, the attribute information identifying a document among one or more selected document subsets, which includes an identified document chunk among one or more identified document chunks.

[0196] Embodiment 67: A computer implementation according to any one of Embodiments 61 to 66, wherein the text query includes a second text query received following a previous text query, and the second text query responds to a previous language output based on the previous text query.

[0197] Embodiment 68: Selecting the first task of the plurality of tasks for the machine learning-trained large language model based at least in part on the text query or at least one of the one or more identified document chunks is: The computing system determines a complexity metric that describes the degree of complexity associated with the query text and / or one or more identified document chunks. The computing system determines that the complexity metric is greater than the threshold for the degree of complexity, The computing system selects a simplified task from among the multiple tasks for the machine-learned large-scale language model based on the determination, A method implemented in a computer according to any one of embodiments 61 to 67, including the method described above.

[0198] Embodiment 69: To perform the task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: To obtain the language output, the computing system processes the prompt based on one or more identified document chunks using the machine learning-prepared large-scale language model, The computing system uses the machine learning-prepared large-scale language model to generate a simplified language output that describes a simplified representation of the language output, A method implemented in a computer according to Embodiment 68, including the following:

[0199] Embodiment 70: A computer-implemented method according to Embodiment 69, further comprising the computing system displaying the simplified language output within the user interface adjacent to the language output.

[0200] Embodiment 71: A computer-implemented method according to Embodiment 69, further comprising the computing system displaying the simplified language output in a second user interface distinct from the user interface.

[0201] Embodiment 72: A computer-implemented method according to Embodiment 69, further comprising the computing system displaying the simplified language output to replace the language output in the user interface.

[0202] Embodiment 73: Selecting the first task of the plurality of tasks for the machine learning-trained large language model based at least in part on the text query or at least one of the one or more identified document chunks is: The computing system determines that the text query and / or one or more identified document chunks contain text content that expresses an opinion. The computing system selects, based on the determination, the opposite view task from among the multiple tasks for the machine-learned large-scale language model, A method implemented in a computer according to any one of embodiments 61 to 67, including the method described above.

[0203] Embodiment 74: To perform the task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: To obtain the language output, the computing system processes the prompt based on one or more identified document chunks using the machine learning-prepared large-scale language model, wherein the language output describes and processes the viewpoint. The computing system uses the machine learning-prepared large-scale language model to generate a second language output that describes a second perspective opposite to the output of the aforementioned perspective. A method implemented in a computer according to Embodiment 73, including the following:

[0204] Embodiment 75: A computer-implemented method according to any one of Embodiments 61 to 67, wherein the first task is an idea expansion task, the one or more identified document chunks comprises a plurality of identified document chunks, and in order to perform the task, processing the prompts based on the one or more identified document chunks using the machine-learned large language model comprises, for a plurality of iterations, processing new prompts by the computing system to obtain updated language output, the new prompts being based on one or more of (a) a subset of identified document chunks from the plurality of identified document chunks, or (b) previously updated language output.

[0205] Embodiment 76: A computer system for dynamic task selection for a large-scale language model, • One or more processors, The system includes one or more non-temporary computer-readable media that, when executed by the one or more processors, collectively store instructions that cause the computing system to perform an operation, and the operation is - Obtain user interaction information that indicates a text query containing at least a portion of the set of text generated by the user through interaction with the text editing field of the user interface, • Using a machine learning-based embedding generation model, generate text embeddings for the text query. - Performing a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-prepared embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query, - Selecting a first task of multiple tasks for a machine learning-trained large-scale language model based at least partially on the text query or at least one of the one or more identified document chunks, - To perform the first of the multiple tasks, the machine learning-trained large-scale language model is used to process prompts based on one or more identified document chunks, - Obtaining language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, including, Computer system.

[0206] Embodiment 77: Before performing the similarity search for the text embeddings with respect to the chunk embeddings generated by the machine learning-trained embedding generation model for each of the chunk embeddings of the chunk - Accessing the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for each of the multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets, and accessing them. - Obtaining data that indicates one or more selected document subsets from the aforementioned plurality of document subsets, A computer system according to embodiment 76, including the computer system described in embodiment 76.

[0207] Embodiment 78: The computer system according to Embodiment 77, wherein obtaining the data indicating the one or more selected document subsets includes obtaining data indicating the selection of one or more selected document subsets from a plurality of document subsets through interaction by the user with the user interface.

[0208] Embodiment 79: The computer system according to any one of Embodiments 77 to 78, wherein performing the similarity search for text embeddings is performed with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, the similarity search comprising performing a similarity search that identifies one or more identified document chunks from the plurality of document chunks contained in the one or more selected document subsets as semantically similar to the text query.

[0209] Embodiment 80: One or more non-temporary computer-readable media that, when executed by one or more processors of a computing system, store instructions that cause the computing system to perform an operation, wherein the operation is - Obtain user interaction information that indicates a text query containing at least a portion of the set of text generated by the user through interaction with the text editing field of the user interface, • Using a machine learning-based embedding generation model, generate text embeddings for the text query. - Performing a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-prepared embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query, - Selecting a first task of multiple tasks for a machine learning-trained large-scale language model based at least partially on the text query or at least one of the one or more identified document chunks, - To perform the first of the multiple tasks, the machine learning-trained large-scale language model is used to process prompts based on one or more identified document chunks, - Obtaining language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, including, One or more non-temporary computer-readable media.

Claims

1. A computer-implemented method for semantic search of a specified subset of multiple documents, A computing system including one or more computing devices receives data representing a text query, The computing system generates text embeddings for the text query using a machine learning-based embedding generation model, The computing system accesses multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets. The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets, The computing system performs a similarity search for the text embeddings with respect only to chunk embeddings associated with document chunks contained in one or more selected document subsets, wherein the similarity search identifies one or more chunk embeddings as semantically similar to the text query. The computing system provides one or more of the document chunks corresponding to one or more of the chunk embeddings identified by the similarity search for display within the user interface. A method of implementation in a computer, including

2. The method implemented in a computer according to claim 1, wherein the user interface includes a text editing interface associated with a document processing application.

3. The user interface includes a primary text editing field that allows the user of the user interface to generate a set of text, The text query includes at least a portion of the set of text generated by the user through interaction with the primary text editing field. A method implemented in a computer according to claim 2.

4. The aforementioned user interface is A primary text editing field that allows the user of the aforementioned user interface to generate a set of text, A query field separate from the primary text editing field, which allows the user to enter the text query separately from the set of text, A method implemented in a computer according to claim 2, including the above.

5. The method of implementing the one or more selected subsets of documents in a computer according to any one of claims 1 to 4, as specified by the user.

6. The computer implementation method according to claim 5, wherein the user interface includes a document subset selection tool that enables the user to provide user input for selecting one or more selected document subsets from the plurality of document subsets.

7. The method implemented in a computer according to claim 6, wherein the document subset selection tool provides a graphical display of the plurality of document subsets.

8. The method implemented on a computer according to claim 6 or 7, wherein the document subset selection tool enables the user to apply a set of filter logic to the plurality of document subsets, and by applying the filter logic, one or more selected document subsets are selected from the plurality of document subsets.

9. A computer implementation method according to any one of claims 1 to 8, wherein at least some of the documents included in the one or more selected subsets of documents include documents provided by the user.

10. At least some of the documents included in the one or more selected document subsets are Books, Product manual, legal opinion, Academic papers, Occupied data file, or Patent Documents A method implemented in a computer according to any one of claims 1 to 9, including the method described in any one of claims 1 to 9.

11. The computing system retrieves the multiple documents, The computing system performs syntactic analysis of the multiple documents into the multiple document chunks, The computing system generates the multiple chunk embeddings using the machine learning-prepared embedding generation model, A computer-implemented method according to any one of claims 1 to 10, further comprising:

12. A computer system for semantic search of a specified subset of multiple documents, One or more processors, One or more non-temporary computer-readable media, The one or more non-temporary computer-readable media include, Multiple chunk embeddings generated by a machine learning-based embedding generation model for multiple document chunks of the aforementioned multiple documents, wherein the aforementioned multiple documents are organized into multiple document subsets, and When executed by the one or more processors, the instructions cause the computer system to perform an action, The above operation stores them collectively, Receiving data that indicates a text query, Using the aforementioned machine learning-based embedding generation model, generate text embeddings for the text query, To obtain data indicating one or more selected document subsets from the aforementioned plurality of document subsets, Performing a similarity search for text embeddings with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, wherein the similarity search identifies one or more chunk embeddings as semantically similar to the text query, To provide one or more of the multiple document chunks corresponding to one or more of the chunk embeddings identified by the similarity search for display within the user interface, including, Computer system.

13. The computer system according to claim 12, wherein the user interface includes a text editing interface associated with a document processing application.

14. The user interface includes a primary text editing field that allows the user of the user interface to generate a set of text, The text query includes at least a portion of the set of text generated by the user through interaction with the primary text editing field. The computer system according to claim 13.

15. The aforementioned user interface is A primary text editing field that allows the user of the aforementioned user interface to generate a set of text, A query field separate from the primary text editing field, which allows the user to enter the text query separately from the set of text, The computer system according to claim 13, including the computer system according to claim 13.

16. The computer system according to any one of claims 12 to 15, wherein the one or more selected subsets of documents are specified by the user.

17. The computer system according to claim 16, wherein the user interface includes a document subset selection tool that enables the user to provide user input for selecting one or more selected document subsets from the plurality of document subsets.

18. The computer system according to claim 17, wherein the document subset selection tool provides a graphical display of the plurality of document subsets.

19. The computer system according to claim 17 or 18, wherein the document subset selection tool enables the user to apply a set of filter logic to the plurality of document subsets, and the application of the filter logic selects one or more selected document subsets from the plurality of document subsets.

20. The aforementioned operation is, Obtaining the aforementioned multiple documents, The process of parsing the aforementioned multiple documents into the aforementioned multiple document chunks, Using the aforementioned machine learning-prepared embedding generation model, the plurality of chunk embeddings are generated, A computer system according to any one of claims 12 to 19, further comprising:

21. A computer-implementable method for large-scale language model interaction with improved explainability, A computing system including one or more computing devices receives data indicating a text query, The computing system generates text embeddings for the text query using a machine learning-based embedding generation model, The computing system performs a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. The computing system generates a prompt containing one or more identified document chunks, The computing system provides the prompts to be processed by the machine learning-trained large-scale language model as input to the machine learning-trained large-scale language model. The computing system receives language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, The computing system provides the language output as output, A method of implementation in a computer, including

22. Before performing the similarity search for the text embeddings with respect to the chunk embeddings generated by the machine learning-prepared embedding generation model for each of the document chunks of the plurality of documents, the method: The computing system accesses the multiple chunk embeddings generated by the machine learning-based embedding generation model for each of the multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets and accessed. A method implemented in a computer according to claim 21, including the method described in claim 21.

23. Accessing the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for each of the multiple document chunks of the multiple documents is: The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets. A method implemented in a computer according to claim 22, further comprising:

24. Performing the similarity search for the aforementioned text embedding means, The computing system performs a similarity search for the text embeddings with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, wherein the similarity search identifies one or more identified document chunks from the plurality of document chunks contained in the one or more selected document subsets as semantically similar to the text query. A method implemented in a computer according to claim 23, including the method described in claim 23.

25. A computer-implemented method according to claim 24, wherein providing the language output as output includes providing the language output for display within a user interface associated with a document processing application by the computing system.

26. The method implemented in a computer according to claim 25, wherein providing the language output for display within the user interface further includes providing attribute information for display within the user interface by the computing system, the attribute information identifying a document among one or more selected document subsets including an identified document chunk among one or more identified document chunks.

27. The method implemented in a computer according to claim 26, wherein the attribute information describes the location of the identified document chunk within the document.

28. The user interface includes a primary text editing field that allows the user of the user interface to generate a set of text, The text query includes at least a portion of the set of text generated by the user through interaction with the primary text editing field. The method implemented in a computer according to claim 25.

29. The method of implementing the one or more selected subsets of documents in a computer according to claim 28, as specified by the user.

30. The aforementioned method, The computing system further includes receiving data indicating a second text query, which includes at least a portion of a second set of text generated by the user through interaction with the primary text editing field, the second set of text responding to the language output. A method implemented in a computer according to any one of claims 28 to 29.

31. The aforementioned method, The computing system generates a second text embedding for the second text query using the machine learning-prepared embedding generation model, The computing system performs a second similarity search for the second text embedding with respect only to chunk embeddings associated with document chunks contained in one or more second document subsets of the plurality of document subsets, wherein the second similarity search identifies one or more second identified document chunks contained in the one or more second document subsets as semantically similar to the second text query. The computing system generates a second prompt containing one or more second identified document chunks, The computing system provides the second prompt for processing by the machine learning-prepared large-scale language model as input to the machine learning-prepared large-scale language model. The computing system receives a second language output generated by the machine learning-prepared large-scale language model based on the processing of the second prompt. The computing system provides a second language output for display within a user interface associated with a document processing application. A method implemented in a computer according to claim 30, further comprising:

32. With respect only to the chunk embeddings associated with the document chunks contained in the one or more second document subsets, before performing the second similarity search for the second text embeddings, The computing system obtains information indicating the user's selection of one or more second document subsets from the plurality of document subsets. A method implemented in a computer according to claim 31, including the following:

33. The computer implementation method according to claim 32, wherein the user interface includes a document subset selection tool that enables the user to provide user input for selecting one or more selected document subsets from the plurality of document subsets.

34. The method implemented in a computer according to claim 33, wherein the document subset selection tool provides a graphical display of the plurality of document subsets.

35. The method implemented on a computer according to claim 33 or 34, wherein the document subset selection tool enables the user to apply a set of filter logic to the plurality of document subsets, and by applying the filter logic, one or more selected document subsets are selected from the plurality of document subsets.

36. With respect only to the chunk embeddings associated with the document chunks contained in the one or more second document subsets, before performing the second similarity search for the second text embeddings, The computing system selects one or more second document subsets from the plurality of document subsets based at least in part on the second set of text generated by the user. A method implemented in a computer according to claim 31, including the following:

37. A computer system for large-scale language model interaction with improved explainability, One or more processors, The system includes one or more non-temporary computer-readable media that, when executed by the one or more processors, collectively store instructions that cause the computer system to perform an operation, and the operation is Receiving data that indicates a text query, Using a machine learning-based embedding generation model, generate text embeddings for the text query, The process involves performing a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. To generate a prompt containing the one or more identified document chunks, The input to a machine learning-prepared large-scale language model is to provide the prompt for processing by the machine learning-prepared large-scale language model, The process of the prompts is to receive the language output generated by the machine learning-prepared large-scale language model, To provide the aforementioned language output as output, A computer system, including a computer system.

38. Before performing the similarity search for the text embeddings with respect to the chunk embeddings generated by the machine learning-prepared embedding generation model for each of the document chunks of the plurality of documents, the operation is performed as follows: Accessing the multiple chunk embeddings generated by the machine learning-based embedding generation model for each of the multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets. The computer system according to claim 37, including the computer system according to claim 37.

39. Accessing the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for each of the multiple document chunks of the multiple documents is: To obtain data indicating one or more selected document subsets from the aforementioned plurality of document subsets. The computer system according to claim 38, further comprising:

40. One or more non-temporary computer-readable media, which, when executed by one or more processors of a computing system, store instructions that cause the computing system to perform an action, wherein the action is Receiving data that indicates a text query, Using a machine learning-based embedding generation model, generate text embeddings for the text query, The process involves performing a similarity search for text embeddings with respect to multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. To generate a prompt containing the one or more identified document chunks, The input to a machine learning-prepared large-scale language model is to provide the prompt for processing by the machine learning-prepared large-scale language model, The process of the prompts is to receive the language output generated by the machine learning-prepared large-scale language model, To provide the aforementioned language output as output, One or more non-temporary computer-readable media, including [the specified text].

Images