Optimizing selection of language tasks to enhance interaction with large language models

Abstract

User interaction information indicative of (a) a textual query and (b) a selected task element selected by a user from a plurality of selectable task elements is obtained. A text embedding of the text query is generated using a machine-learned embedding generation model. A similarity search is performed on a text insert for a plurality of block inserts generated by a machine learning insert generation model for each of a plurality of document blocks of a plurality of documents. A similarity search identifies an identified document chunk of the plurality of document chunks as semantically similar to the textual query. A hint is processed based on the identified document block using a large language model to perform a task associated with the selected task element. A language output is generated based on the processing of the hint using a large language model.

Description

Technical Field

[0001] This disclosure generally relates to optimizing the task performance of large language models. More specifically, this disclosure relates to optimizing the interaction between the user and the large language model when selecting tasks for the large language model. Background Technology

[0002] Large language models are models trained on massive datasets. This training approach enables them to perform a wide variety of language tasks. For example, some language models can simplify text, generate opposing opinions, facilitate brainstorming, and respond to user queries in a conversational manner. When combined, these tasks can foster conversational dialogue between the model and the user, thus providing relevant information more efficiently. However, the sheer variety of tasks that large language models can perform makes choosing a specific task at any given time difficult. Summary of the Invention

[0003] Various aspects and advantages of embodiments of this disclosure will be set forth in part in the description which follows, or may be learned from the description or by practice of the embodiments.

[0004] One example aspect of this disclosure relates to a computer-implemented method for facilitating the selection of a specific language task to enhance user interaction with a large language model. The method includes obtaining user interaction information by a computing system comprising one or more computing devices, instructing: (a) a text query comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface, wherein the user interface includes the text editing field and a plurality of optional task elements associated with a plurality of tasks of a machine learning large language model, respectively; and (b) a selected task element selected by the user from the plurality of optional task elements. The method includes generating a text embedding of the text query by the computing system using a machine learning embedding generation model. The method includes performing a similarity search on the text embedding by the computing system for a plurality of block embeddings generated by the machine learning embedding generation model for a plurality of document blocks of a plurality of documents, wherein the similarity search identifies one or more identified document blocks among the plurality of document blocks as semantically similar to the text query. The method includes processing prompts based on the one or more identified document blocks by the computing system using the machine learning large language model to perform a task associated with the selected task element among the plurality of tasks. The method includes obtaining language output generated by the computational system based on the processing of the prompt by the machine learning large language model.

[0005] Another example aspect of this disclosure relates to a computer system for facilitating the selection of a specific language task to enhance user interaction with a large language model. The computer system includes one or more processors and one or more non-transitory computer-readable media sharing instructions that, when executed by the one or more processors, cause the computer system to perform operations. These operations include obtaining user interaction information instructing: (a) a text query comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface, wherein the user interface includes the text editing field and a plurality of optional task elements associated with multiple tasks of a machine learning large language model, respectively; and (b) a selected task element selected by the user from the plurality of optional task elements. These operations include generating a text embedding of the text query using a machine learning embedding generation model. These operations include performing a similarity search on the text embeddings for a plurality of block embeddings generated by the machine learning embedding generation model for a plurality of document blocks of a plurality of documents, wherein the similarity search identifies one or more of the identified document blocks among the plurality of document blocks as semantically similar to the text query. These operations include using the machine learning large language model to process prompts based on one or more identified document blocks to perform a task associated with the selected task element among a plurality of tasks. These operations include obtaining language output generated by the machine learning large language model based on the processing of the prompts.

[0006] Another example aspect of this disclosure relates to a non-transitory computer-readable medium storing one or more instructions that, when executed by one or more processors of a computing system, cause the computing system to perform operations. These operations include obtaining user interaction information instructing: (a) a text query comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface, wherein the user interface includes the text editing field and a plurality of optional task elements associated with a plurality of tasks of a machine learning large language model; and (b) a selected task element selected by the user from the plurality of optional task elements. These operations include generating a text embedding of the text query using a machine learning embedding generation model. These operations include performing a similarity search on the text embeddings for a plurality of block embeddings generated by the machine learning embedding generation model for a plurality of document blocks of a plurality of documents, wherein the similarity search identifies one or more identified document blocks among the plurality of document blocks as semantically similar to the text query. These operations include using the machine learning large language model to process a prompt based on the one or more identified document blocks to perform a task associated with the selected task element among the plurality of tasks. These operations include obtaining language output generated by the machine learning large language model based on the processing of the prompt.

[0007] Another exemplary aspect of this disclosure relates to a computer-implemented method for dynamic task selection for a large language model. The method includes obtaining user interaction information indicating a text query by a computing system including one or more computing devices, the text query comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface. The method includes generating a text embedding of the text query by the computing system using a machine learning embedding generation model. The method includes performing a similarity search on the text embedding by the computing system for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, wherein the similarity search identifies one or more identified document blocks among the multiple document blocks as semantically similar to the text query. The method includes selecting a first task among multiple tasks for a machine learning large language model by the computing system at least in part based on the text query or at least one of the one or more identified document blocks. The method includes processing a prompt based on the one or more identified document blocks by the computing system using the machine learning large language model to perform the first task among the multiple tasks. The method includes obtaining language output generated by the machine learning large language model based on the processing of the prompt by the computing system.

[0008] Another exemplary aspect of this disclosure relates to a computer system for dynamic task selection for a large language model. The computer system includes one or more processors and one or more non-transitory computer-readable media sharing instructions that, when executed by the one or more processors, cause the computer system to perform operations. These operations include obtaining user interaction information indicating a text query, the text query comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface. These operations include generating a text embedding of the text query using a machine learning embedding generation model. These operations include performing a similarity search on the text embeddings for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, wherein the similarity search identifies one or more identified document blocks among the multiple document blocks as semantically similar to the text query. These operations include selecting a first task among multiple tasks for the machine learning large language model, at least in part based on the text query or at least one of the one or more identified document blocks. These operations include using the machine learning large language model to process a prompt based on the one or more identified document blocks to perform the first task among the multiple tasks. These operations include obtaining language output generated by the machine learning large language model based on the processing of the prompt.

[0009] Another example aspect of this disclosure relates to a non-transitory computer-readable medium storing one or more instructions that, when executed by one or more processors of a computing system, cause the computing system to perform operations. These operations include obtaining user interaction information indicating a text query, the text query comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface. These operations include generating a text embedding of the text query using a machine learning embedding generation model. These operations include performing a similarity search on the text embeddings for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, wherein the similarity search identifies one or more identified document blocks among the multiple document blocks as semantically similar to the text query. These operations include selecting a first task among multiple tasks for a machine learning large language model, at least in part based on the text query or at least one of the one or more identified document blocks. These operations include using the machine learning large language model to process a prompt based on the one or more identified document blocks to perform the first task among the multiple tasks. These operations include obtaining language output generated by the machine learning large language model based on the processing of the prompt.

[0010] Other aspects of this disclosure relate to various systems, devices, non-transitory computer-readable media, user interfaces, and electronic devices.

[0011] These and other features, aspects, and advantages of the various embodiments of this disclosure will be better understood with reference to the following description and the appended claims. The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate exemplary embodiments of the disclosure and, together with the description, serve to illustrate the relevant principles. Attached Figure Description

[0012] Referring to the accompanying drawings, a detailed discussion of embodiments is set forth in this specification for those skilled in the art, in which:

[0013] Figure 1A A block diagram of an example computing system optimized for user interaction and task selection of a large language model according to an example embodiment of the present disclosure is depicted.

[0014] Figure 1B A block diagram of an example computing apparatus is depicted that performs semantic exploration on a specified subset of multiple documents according to an example embodiment of the present disclosure.

[0015] Figure 1C A block diagram of an example computing device is depicted that facilitates the selection of a specific language task to enhance user interaction with a large language model according to an example embodiment of the present disclosure.

[0016] Figure 2A block diagram depicts an example machine learning large language model according to an example embodiment of the present disclosure.

[0017] Figure 3 A block diagram depicts an example machine learning language model integration according to an example embodiment of the present disclosure.

[0018] Figure 4 An example user interface for facilitating interaction between the user and a large language model is depicted according to some implementations of this disclosure.

[0019] Figure 5A The present disclosure describes some implementations of the same as those described above. Figure 4 The example user interface demonstrates user interaction for assigning documents to subsets of documents.

[0020] Figure 5B Describing some other implementations of this disclosure and Figure 4 The example user interface demonstrates user interaction for assigning documents to subsets of documents.

[0021] Figure 6A The present disclosure describes some implementations of the same as those described above. Figure 4 The example user interface demonstrates user interaction to select a subset of documents from multiple document subsets.

[0022] Figure 6B The present disclosure describes some implementations of the same as those described above. Figure 4 The example user interface demonstrates user interaction to provide queries via query fields.

[0023] Figure 7A Example user interfaces for interacting with a large language model according to some implementations of this disclosure are depicted to request the model to perform a summary task.

[0024] Figure 7B Examples of use cases based on some implementations of this disclosure are depicted, showing user interface interactions with a large language model to request the model to perform an opposing viewpoint task.

[0025] Figure 7C Example user interfaces for using some implementations of this disclosure are depicted, along with additional user interactions with a large language model to request the model to perform a brainstorming task.

[0026] Figure 7D Examples of use cases based on some implementations of this disclosure are depicted, showing user interfaces and additional user interactions with a large language model to request the model to perform simplified tasks.

[0027] Figure 8 Various interface layouts that can be implemented according to some of the implementation methods of this disclosure to realize the interface in the foregoing figures are described.

[0028] Figure 9 A flowchart is depicted illustrating an example method for performing semantic exploration on a specified subset of multiple documents according to an example embodiment of this disclosure.

[0029] Figure 10 A flowchart is depicted illustrating an example method for performing large language model interactions with improved interpretability according to an example embodiment of this disclosure.

[0030] Figure 11 A flowchart is depicted illustrating an example method for enhancing user interaction with a large language model by facilitating the selection of a specific language task according to an example embodiment of this disclosure.

[0031] Figure 12 A flowchart is provided illustrating an example method for performing dynamic task selection on a large language model according to an example embodiment of the present disclosure.

[0032] Repeated reference numerals in multiple figures are intended to identify the same features in various implementations. Detailed Implementation

[0033] Overview

[0034] This disclosure generally relates to optimizing the task performance of large language models. More specifically, this disclosure relates to optimizing the interaction between a user and a large language model when selecting tasks for the model. As an example, a computational system may obtain a text query from a user. A machine learning embedding generative model can be used to process the text query to generate a text embedding of the query. The query can be used to access multiple chunk embeddings within an embedding space. Each chunk embedding may correspond to a chunk of a document, which can be organized into various subsets of documents. For example, a user may collect ten different types of documents (e.g., articles, patent documents, research papers, websites, etc.) and categorize them into document subsets by type (e.g., if four out of ten documents are patent documents, they can be categorized into their own document subset).

[0035] The computing system can obtain data indicating that a user has selected a subset of documents. The system can then perform a similarity search between the query embedding and the embeddings of only those blocks associated with document blocks included in the selected document subset to identify one or more identified document blocks.

[0036] In some implementations, the identified document blocks can be presented directly to the user within the user interface. For example, a user might be interacting with a word processing application, and the identified document blocks could be displayed within the margins of a Word document. Alternatively, the identified document blocks could be provided within an interface, and could include attribution information (e.g., references) indicating the location of each document block within its corresponding document.

[0037] Additionally or alternatively, in some implementations, the computational system may use the identified document chunks as input to a large language model to provide more information to the user. For example, the computational system may generate prompts that include the identified document chunks. The computational system may then provide the prompts as input to a machine learning large language model (e.g., the model can be used to process the prompts, the prompts can be provided to a remote service implementing the model, etc.) to receive the language output generated by the model. The language output may then be provided to the user.

[0038] In some implementations, the user can specify a particular task for the machine learning large language model to perform. For example, the user interface can include various optional task elements corresponding to specific tasks that the machine learning large language model can perform (e.g., simplification, summarization, opposing viewpoints, etc.). The computational system can obtain information indicating that the user has selected one of these task elements. The computational system can then use the machine learning large language model to perform the task corresponding to that task element to obtain a large language output that completes the task. For a specific example, the computational system can obtain information indicating that the user has selected the summarization task. The computational system can use the machine learning large language model to process the identified document blocks to obtain language output. The computational system can then use the machine learning large language model to generate a summary output that summarizes the language output. Alternatively, instead of generating language output, the computational system can generate an initial language output summarizing the identified document blocks.

[0039] Alternatively, in some implementations, the computational system can automatically determine which task to select for performance by the machine learning large language model. For example, the computational system can identify identified document blocks and determine that the identified document blocks and / or text queries from the user represent a specific viewpoint. Based on the identified document blocks and / or text queries, the computational system can select an opposing viewpoint task. The computational system can then use the machine learning large language model to generate language output describing a viewpoint contrary to that expressed by the identified document blocks and / or text queries. In this way, the computational system can facilitate interaction between the user and the machine learning large language model to optimize information delivery to the user.

[0040] This disclosure offers several technical effects and benefits. As an example, users of traditional search processes, word processing applications, etc., typically have to spend considerable time and effort browsing and analyzing references and researching background information to understand complex and difficult concepts. However, by optimizing the interaction between the user and a large language model in machine learning and facilitating model task selection, the implementation of this disclosure can significantly reduce the time users spend using computing devices for research. For example, instead of spending hours manually searching complex academic papers for information, the implementation of this disclosure optimizes the interaction between the user and the large language model to provide the same information to the user within minutes. Furthermore, this eliminates the expenditure of significant computing resources (e.g., computation cycles, power, memory, etc.) that users would otherwise consume. Moreover, by reducing the user's time expenditure, the implementation of this disclosure can improve efficiency in many use cases (e.g., software engineering, medical research, citation documentation for research papers, etc.).

[0041] Exemplary embodiments of this disclosure will now be discussed in further detail with reference to the accompanying drawings.

[0042] Example devices and systems

[0043] Figure 1A A block diagram of an example computing system 100 optimized for user interaction and task selection of a large language model according to an exemplary embodiment of the present disclosure is depicted. System 100 includes a user computing device 102, a server computing system 130, and a training computing system 150 communicatively coupled via a network 180.

[0044] User computing device 102 can be any type of computing device, such as, for example, a personal computing device (e.g., a laptop or desktop computer), 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.

[0045] User computing device 102 includes one or more processors 112 and memory 114. The one or more processors 112 can be any suitable processing device (e.g., processor core, microprocessor, ASIC, FPGA, controller, microcontroller, etc.) and can be a single processor or multiple processors operatively connected. Memory 114 can include one or more non-transitory computer-readable storage media, such as RAM, ROM, EEPROM, EPROM, flash memory devices, disks, etc., and combinations thereof. Memory 114 can store data 116 and instructions 118, which are executed by processor 112 to cause user computing device 102 to perform operations.

[0046] In some implementations, the user computing device 102 may store or include one or more models 120. For example, model 120 may be, or may otherwise include, various machine learning models, such as neural networks (e.g., deep neural networks), large language models (LLMs), or other types of machine learning models, including nonlinear and / or linear models. 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 example machine learning models may utilize attention mechanisms, such as self-attention. For example, some example machine learning models may include multi-head self-attention models (e.g., transformer models). Reference Figure 2 and Figure 3 Example model 120 was discussed.

[0047] In some implementations, one or more models 120 may be received from server computing system 130 via network 180, stored in user computing device memory 114, and then used or otherwise implemented by one or more processors 112. In some implementations, user computing device 102 may implement multiple parallel instances of a single model 120 (e.g., multiple instances across model 120 perform parallel optimization on user interactions and task selection for a large language model).

[0048] More specifically, in some implementations, model 120 may include a machine learning embedding generative model. The machine learning embedding generative model can be one or more models of any type or manner sufficient to generate an intermediate representation of the query (e.g., a model architecture including multiple models). In some implementations, the query can be a text query, and the machine learning embedding generative model can generate a text embedding of the text query. Alternatively, in some implementations, the query can be an image query, a video query, a gesture query, a contextual query (e.g., a query including contextual information (e.g., location, pose, environment, time, etc.), a multimodal query (e.g., text and image input, etc.)), and the machine learning embedding generative model can generate an intermediate representation of the query (e.g., an embedding).

[0049] Additionally or alternatively, in some implementations, model 120 may include a machine learning large language model. The machine learning large language model may be, or otherwise include, a model trained on a large corpus of language training data in a manner that enables the machine learning large language model to perform multiple language tasks. For example, the machine learning large language model may be trained to perform summarizing tasks, conversational tasks, simplification tasks, opposing viewpoint tasks, etc. Specifically, the machine learning large language model may be trained to process various outputs to generate language output. For example, the machine learning large language model may process embeddings generated by a machine learning embedding generation model, document blocks identified using the embedding generation model, language output generated using the machine learning large language model or some other model, etc.

[0050] Additionally or alternatively, one or more models 140 may be included in or otherwise stored and implemented by the server computing system 130, which communicates with the user computing device 102 according to a client-server relationship. For example, model 140 may be implemented by the server computing system 130 as part of a web service (e.g., a word processing service, etc.). Thus, one or more models 120 may be stored and implemented at the user computing device 102, and / or one or more models 140 may be stored and implemented at the server computing system 130.

[0051] User computing device 102 may also include one or more user input components 122 for receiving user input. For example, user input component 122 may be a touch-sensitive component (e.g., a touch-sensitive display or touchpad) that is sensitive to the touch of a user input object (e.g., a finger or stylus). Touch-sensitive components may be used to implement a virtual keyboard. Other example user input components include microphones, conventional keyboards, or other components through which a user can provide user input.

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

[0053] In some implementations, the server computing system 130 includes one or more server computing devices or is otherwise implemented by such one or more server computing devices. Where the server computing system 130 includes multiple server computing devices, these server computing devices may operate according to a sequential computing architecture, a parallel computing architecture, or some combination thereof.

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

[0055] Specifically, model 140 of server computing system 130 may include some or all of model 120 included in user computing device 102, and these models may be provided as a service to user computing device 102. For example, in some implementations, model 140 may include a machine learning embedding generative model. Server computing system 130 may also maintain an embedding space that includes embeddings generated using the machine learning embedding generative model. User computing device 102 may provide a query to server computing system 130, and server computing system 130 may process the query using the machine learning embedding generative model to obtain an intermediate representation of the query.

[0056] In some implementations, server computing system 130 may return an intermediate representation of the query to user computing device 102. Alternatively, in some implementations, machine learning model 140 may include a large language model, and server computing system 130 may use the large language model to process the intermediate representation to obtain language output. The language output, or information indicating or otherwise describing the language output, may be provided to user computing device 102.

[0057] User computing device 102 and / or server computing system 130 can train models 120 and / or 140 via interaction with training computing system 150, which is communicatively coupled through network 180. Training computing system 150 may be separate from server computing system 130 or may be part of server computing system 130.

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

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

[0060] In some implementations, performing error backpropagation may include performing backpropagation through time with truncation. The model trainer 160 may perform various generalization techniques (e.g., weight decay, dropout, etc.) to improve the generalization ability of the model being trained.

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

[0062] In some implementations, training examples can be provided by the user computing device 102 if the user has given consent. Therefore, in such implementations, the model 120 provided to the user computing device 102 can be trained by the training computing system 150 based on user-specific data received from the user computing device 102. In some cases, this process can be referred to as model personalization.

[0063] Model trainer 160 includes computer logic for providing desired functionality. Model trainer 160 can be implemented using hardware, firmware, and / or software that controls a general-purpose processor. For example, in some implementations, model trainer 160 includes a program file stored on a storage device, loaded into memory, and executed by one or more processors. In other implementations, model trainer 160 includes one or more sets of computer-executable instructions stored in a tangible computer-readable storage medium (such as RAM, hard disk, or optical or magnetic media).

[0064] Network 180 can be any type of communication network, such as a local area network (e.g., intranet), a wide area network (e.g., the Internet), or some combination thereof, and can include any number of wired or wireless links. Generally, communication over network 180 can be performed via any type of wired and / or wireless connection using various communication protocols (e.g., TCP / IP, HTTP, SMTP, FTP), encodings or formats (e.g., HTML, XML), and / or protection schemes (e.g., VPN, Secure HTTP, SSL).

[0065] In some implementations, the input to the machine learning model of this disclosure can be image data. The machine learning model can process the image data to generate output. As an example, the machine learning model can process image data to generate image recognition output (e.g., image data identification, latent embedding of image data, encoded representation of image data, hashing of image data, etc.). As another example, the machine learning model can process image data to generate image segmentation output. As another example, the machine learning model can process image data to generate image classification output. As another example, the machine learning model can process image data to generate image data modification output (e.g., image data alteration, etc.). As another example, the machine learning model can process image data to generate encoded image data output (e.g., encoded and / or compressed representation of image data, etc.). As another example, the machine learning model can process image data to generate magnified image data output. As another example, the machine learning model can process image data to generate prediction output.

[0066] In some implementations, the input to the machine learning model of this disclosure can be text or natural language data. The machine learning model can process the text or natural language data to generate output. As an example, the machine learning model can process natural language data to generate language-encoded output. As another example, the machine learning model can process text or natural language data to generate latent text embedding output. As another example, the machine learning model can process text or natural language data to generate transformation output. As another example, the machine learning model can process text or natural language data to generate classification output. As another example, the machine learning model can process text or natural language data to generate text segmentation output. As another example, the machine learning model can process text or natural language data to generate semantic intent output. As another example, the machine learning model can process text or natural language data to generate amplified text or natural language output (e.g., text or natural language data of higher quality than the input text or natural language, etc.). As another example, the machine learning model can process text or natural language data to generate predictive output.

[0067] In some implementations, the input to the machine learning model of this disclosure can be speech data. The machine learning model can process the speech data to generate an output. As an example, the machine learning model can process speech data to generate a speech recognition output. As another example, the machine learning model can process speech data to generate a speech translation output. As another example, the machine learning model can process speech data to generate a latent embedding output. As another example, the machine learning model can process speech data to generate an encoded speech output (e.g., an encoded representation and / or a compressed representation of the speech data, etc.). As another example, the machine learning model can process speech data to generate an amplified speech output (e.g., speech data of higher quality than the input speech data, etc.). As another example, the machine learning model can process speech data to generate a text representation output (e.g., a text representation of the input speech data, etc.). As another example, the machine learning model can process speech data to generate a predicted output.

[0068] In some implementations, the input to the machine learning model of this disclosure can be latent encoded data (e.g., a latent spatial representation of the input). The machine learning model can process the latent encoded data to generate an output. As an example, the machine learning model can process the latent encoded data to generate an identification output. As another example, the machine learning model can process the latent encoded data to generate a reconstruction output. As another example, the machine learning model can process the latent encoded data to generate a search output. As another example, the machine learning model can process the latent encoded data to generate a re-clustering output. As yet another example, the machine learning model can process the latent encoded data to generate a prediction output.

[0069] In some implementations, the input to the machine learning model of this disclosure can be statistical data. Statistical data can be, represent, or otherwise include data calculated and / or computed from another data source. The machine learning model can process the statistical data to generate output. As an example, the machine learning model can process the statistical data to generate an identification output. As another example, the machine learning model can process the statistical data to generate a prediction output. As another example, the machine learning model can process the statistical data to generate a classification output. As another example, the machine learning model can process the statistical data to generate a segmentation output. As another example, the machine learning model can process the statistical data to generate a visualization output. As another example, the machine learning model can process the statistical data to generate a diagnostic output.

[0070] In some implementations, the input to the machine learning model of this disclosure can be sensor data. The machine learning model can process the sensor data to generate output. As an example, the machine learning model can process sensor data to generate identification output. As another example, the machine learning model can process sensor data to generate prediction output. As another example, the machine learning model can process sensor data to generate classification output. As another example, the machine learning model can process sensor data to generate segmentation output. As another example, the machine learning model can process sensor data to generate visualization output. As another example, the machine learning model can process sensor data to generate diagnostic output. As yet another example, the machine learning model can process sensor data to generate detection output.

[0071] In some cases, the input includes visual data, and the task is a computer vision task. In other cases, the input includes pixel data for one or more images, and the task is an image processing task. For example, an image processing task could be image classification, where the output is a set of scores, each corresponding to a different object class and representing the probability that the one or more images depict an object belonging to that object class. An image processing task could be object detection, where the image processing output identifies one or more regions in one or more images, and for each region, identifies the probability that the region depicts an object of interest. As another example, an image processing task could be image segmentation, where the image processing output defines a corresponding probability for each of a predetermined set of categories for each pixel in one or more images. For example, the set of categories could be foreground and background. As another example, the set of categories could be object classes. As another example, an image processing task could be depth estimation, where the image processing output defines a corresponding depth value for each pixel in one or more images. As another example, an 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 at each pixel in one of the input images between the images in the network input.

[0072] Figure 1A An example computing system that can be used to implement this disclosure is shown. Other computing systems may also be used. For example, in some implementations, user computing device 102 may include a model trainer 160 and a training dataset 162. In such implementations, model 120 may be trained locally at user computing device 102 and both may be used. In some such implementations, user computing device 102 may implement model trainer 160 to personalize model 120 based on user-specific data.

[0073] Figure 1B A block diagram of an example computing device 10 is depicted, which performs semantic exploration on a specified subset of multiple documents according to an example embodiment of the present disclosure. The computing device 10 may be a user computing device or a server computing device.

[0074] The computing device 10 includes multiple applications (e.g., application 1 to application N). Each application contains its own machine learning library and machine learning model. For example, each application may include a machine learning model. Example applications include a text messaging application, an email application, a dictation application, a virtual keyboard application, a browser application, etc.

[0075] like Figure 1BAs illustrated, each application can communicate with multiple other components of the computing device, such as, for example, one or more sensors, a context manager, a device state component, and / or additional components. In some implementations, each application can communicate with each device component using an API (e.g., a public API). In some implementations, the API used by each application is application-specific.

[0076] Figure 1C A block diagram of an example computing device 50, illustrating an exemplary embodiment of the present disclosure, is provided to facilitate the selection of specific language tasks to enhance user interaction with a large language model. The computing device 50 may be a user computing device or a server computing device.

[0077] The computing device 50 includes multiple applications (e.g., application 1 to application N). Each application communicates with a central intelligence layer. Example applications include a text messaging application, an email application, a dictation application, a virtual keyboard application, a browser application, etc. In some implementations, each application may use an API (e.g., a common API across all applications) to communicate with the central intelligence layer (and the models stored therein).

[0078] The central intelligence layer comprises multiple machine learning models. For example, such as... Figure 1C As illustrated, a corresponding machine learning model can be provided for each application, and the corresponding machine learning model can be managed by a central intelligent layer. In other implementations, two or more applications can share a single machine learning model. For example, in some implementations, the central intelligent layer can provide a single model for all applications. In some implementations, the central intelligent layer is included within or otherwise implemented by the operating system of the computing device 50.

[0079] The central intelligence layer can communicate with the central device data layer. The central device data layer can be a centralized storage repository for data from the computing device 50. For example... Figure 1C As illustrated, the central device data layer can communicate with multiple other components of the computing device, such as, for example, one or more sensors, a context manager, a device state component, and / or additional components. In some implementations, the central device data layer may use an API (e.g., a private API) to communicate with each device component.

[0080] Example model layout

[0081] Figure 2A block diagram of an example machine learning large language model 200 according to an exemplary embodiment of the present disclosure is depicted. In some implementations, the machine learning large language model 200 is trained to receive a set of input data 204, which is or otherwise describes identified document blocks, and as a result of receiving the input data 204, provides output data 206 describing the language output.

[0082] In some implementations, input data 204 may further indicate a specific task among multiple tasks that can be performed by the machine learning large language model 200. For example, input data 204 may include identified document blocks 204A and may indicate a summarization task 204B. The machine learning large language model 200 may process input data 204 to generate output data 206 describing the language output summarizing the identified document blocks.

[0083] Figure 3 A block diagram of an example machine learning language model ensemble 300 according to an exemplary embodiment of the present disclosure is depicted. The machine learning language model 300 ensemble includes a machine learning embedding generative model 302 and a large language model 306, which is similar to... Figure 2 The difference is that the large language model 306 is included in the machine learning language model ensemble 300 along with the machine learning embedding generative model 302.

[0084] As an example, input data 304 can include Figure 2 The specified task 204B and text query 308. Text query 308 can be a query from a user to an integration of a machine learning language model. Machine learning embedding generative model 302 can process text query 308 to obtain an intermediate representation 310 of text query 308. The intermediate representation 310 can be used to perform a search on an embedding space 312, which includes embeddings generated by machine learning embedding generative model 302. An embedding is an embedding of document blocks organized into a subset 314 of documents.

[0085] Specifically, the machine learning embedding generative model 302 can process the intermediate representation 310 to identify block embeddings 316 that are semantically similar to the text query 308. The identified document blocks 318 can then be obtained from the document subset 320. The identified document block 318 is the document block in the document subset 320 that corresponds to the identified block embedding 316.

[0086] The large language model 306 can process the identified document block 318 to generate output data 206 describing the language output. In some implementations, the large language model 306 can also process based on a specified task 204B, or be otherwise adapted based on that specified task. For example, the specified task 204B can be a summarizing task. The large language model 306 can be adapted to perform the summarizing task based on the specified task 204B. The large language model 306 can then process the identified document block 318 to generate output data 206 that describes the language output including the summary of the identified document block 318.

[0087] Example implementation

[0088] Figure 4 Example user interface 400 for facilitating interaction between a user and a large language model is depicted according to some implementations of this disclosure. Specifically, interface 400 may be an interface for a word processing application (e.g., a web application). Interface 400 may include multiple documents 402A-402Q (collectively referred to as documents 402). Some documents 402 may be organized into document subsets 404, 406, 408, and 410. Other documents 402 may be unassigned. According to the depicted example, a first document subset 404 (e.g., document bottle 1) may be a subset of academic papers and may include documents (e.g., academic paper documents) 402A, 402B, and 402C. A second document subset 406 may be a subset of patent documents and may include documents (e.g., patent documents) 402D, 402E, and 402F. A third document subset 408 may be a subset of newspaper articles or clippings and may include documents (e.g., clippings) 402G, 402H, and 402I. The fourth document subset 410 may be a subset of files (e.g., program instruction files, PowerPoint 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 portion 412, which includes unassigned documents 402M, 402N, 402O, 402P, and 402Q.

[0089] Figure 5A The present disclosure describes some implementations of the same as those described above. Figure 4 The example user interface 400 demonstrates user interaction for assigning documents to subsets of documents. Specifically, in Figure 5AIn this example, the user has manually assigned document 402M to document subset 404. More specifically, the user has used an input device (e.g., mouse, touchpad, etc.) to manipulate the cursor and drag document 402M to the document subset 404 associated with the academic paper. The user can manually assign each document from 402M to 402Q to the document subsets 404-410 to which it 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.

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

[0091] Figure 5B Describing some other implementations of this disclosure and Figure 4 The example user interface 400 demonstrates user interaction for assigning documents to subsets of documents. Specifically, in Figure 5B In this implementation, the user has provided selection input to the categorization element 416. The categorization element 416 enables the computing system implementing interface 400 to automatically categorize unassigned documents 402M-402Q into existing document subsets 404-410. In some implementations, the computing system can categorize unassigned documents 402M-402Q by determining the document type of each document within these documents. For example, the computing system can determine that document 402M is an academic paper and therefore should be assigned to the document subset 404 associated with academic papers. As another example, the computing system can determine that document 402N is a clipping and therefore should be assigned to the document subset 408 associated with clippings.

[0092] Alternatively, in some implementations, the computational system can assign unassigned documents 402M-402Q to existing document subsets 404-410 based on some other metric or heuristic. For example, the computational system can determine the semantic understanding of each document (e.g., whether the document's "tone" is generally negative or positive) and can assign unassigned documents 402M-402Q based on the determined semantic understanding. As another example, the computational system can assign one of the unassigned documents 402M-402Q to one of several determinations. For instance, if document subset 406 is used for positive clippings and document subset 408 is used for negative clippings, the computational system can first determine that document 402N is a clipping, then determine that the clipping is semantically negative, and therefore should be assigned to document subset 408.

[0093] More generally, it should be understood that the computing system can assign documents to document subset 408 based on any type or manner of criteria (e.g., title, subject, semantic understanding, length, publication date, public accessibility, relevance, document type, etc.). In some implementations, document subsets and document types can be associated with different degrees of specificity. For example, the computing system can maintain a relatively strict association between document subset 404 and academic paper type documents, and a relatively loose association between document subset 408 and clipping type documents. Based on these maintained associations, the computing system can determine to avoid assigning document 402P to document subset 404 (e.g., due to the strict association between this subset and the academic paper document type), and instead assign document 402P to document subset 408 (e.g., due to the loose association between this subset and the clipping document type).

[0094] Figure 6A The present disclosure describes some implementations of the same as those described above. Figure 4 The example user interface 400 allows for user interaction to select a subset of documents from multiple document subsets. Specifically, in some implementations, the user can provide cursor input 602 to select a document subset 404. Alternatively, in some implementations, the user can 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 can provide a query 604 to the computing system in the query field 606, asking "how much genetic drift has occurred in cats?", and instruct the computing system to determine this information based on the documents assigned to the document subset 404.

[0095] Figure 6B The present disclosure describes some implementations of the same as those described above. Figure 4Example user interface 400 provides user interaction to provide queries via query fields. Specifically, query field 604 can be used to facilitate user interaction with a large language model (e.g., Figure 2 The interaction between machine learning large language models (e.g., 200, etc.). As illustrated in the example, users can provide information about... Figure 6A The query is described. The computing system can process query 604 to obtain output 608. In some implementations, the computing system can use (e.g., as about...) Figure 3 The machine learning embedding model described above processes query 604 to identify document blocks that are semantically similar to query 604 and can return that block as output 608. Alternatively, in some implementations, the computational system can use (e.g., as per [reference to...]) Figure 3 The machine learning large language model is used to process the identified document blocks to obtain output 608, which includes language output.

[0096] The computing system can provide output 608 for display within query field 606 of interface 400. A user can provide a second query 610 within query field 604, and the computing system can process the second query 610 in the same manner to generate a second output 612 for display within query field 606. Additionally, in some implementations, the computing system can provide attribution information 614 for display within interface 400. Attribution information 614 can identify the document upon which language output 612 is based. In some implementations, if output 612 includes a specific document block from document 402, attribution information 614 can describe the specific location of the identified document block within its source document 402. For example, attribution information 614 can be, or otherwise describes, a reference in a specific citation format that identifies the location of the document block (e.g., MLA, Chicago Style, Blue Book, etc.). As another example, attribution information 614 can include a link that, when selected by a user, navigates the user to the location within the document from which the document block originates.

[0097] Figure 7A An example user interface 700, based on some implementations of this disclosure, is depicted interacting with a large language model to request the model to perform a summary task. Specifically, Figure 7A The interface can respond to user input, including information such as "about". Figure 6BThe interface 700 is presented in response to the user's selection of optional links in the attribution information 614. Once document 402M is displayed, the interface 700 can facilitate further interaction between the user and the large language model. For example, the user can provide a query 702 requesting the performance of a summary task. Specifically, query 702 includes a text query from the user (e.g., "summarize this passage") and identified (i.e., highlighted) document blocks 704. The computing system can process query 702 using a machine learning embedding model to obtain the embedding of the query, and can process the embedding of the query using a machine learning large language model to obtain language output 706. Language output 706 can summarize the identified document blocks 704.

[0098] Users can provide additional queries 708 that instruct the computing system to navigate to different documents. The computing system can process query 708 to determine instructions for navigating to different documents. For example, the computing system can use a machine learning large language model to process query 708 to determine instructions.

[0099] Figure 7B An example user interface 700, based on some implementations of this disclosure, is depicted for additional user interaction with a large language model to request the model to perform an opposing viewpoint task. Specifically, Figure 7B The interface 700 can include responses Figure 7A The document 402H described in query 708 is referenced. In some implementations, in addition to displaying document 402H, the computing system may also provide various task elements 710, each corresponding to a specific task that can be performed by a large language model in machine learning. For example, task element 710A corresponds to performing an action regarding... Figure 7A The task description summarizes the task. Task element 710B corresponds to performing a simplification task. Task element 710C corresponds to performing an opposing viewpoint task (i.e., "opposite" opinions). Finally, task element 710D corresponds to a brainstorming task.

[0100] The user can select task element 710C. In response, the computing system can use a machine learning large language model to perform an opposing viewpoint task to generate language output 712. Language output 712 can describe an opinion contrary to that expressed in document 402H (or a related identified document block of document 402H). Following the depicted example, the user can select opposing viewpoint element 706C and select (e.g., highlight, etc.) a document block from document 402H. The computing system can process this document block to perform an opposing viewpoint task, thereby generating language output 712 describing an opinion contrary to that expressed in the document block. In some implementations, the computing system can determine that the text content expresses an opinion, and based on this determination, can select an opposing viewpoint task for the machine learning large language model.

[0101] Figure 7C Example user interface 700, based on some implementations of this disclosure, is depicted for additional user interaction with a large language model to request the model to perform a brainstorming task. Specifically, such as Figure 7C As shown, the user can select brainstorming task 706D. In some implementations, the computing system can query which subset of documents to use to perform the brainstorming task. For example, the user can specify that they want to perform brainstorming based on document subset 2 (e.g., document subset 406 associated with patent documents). In response, the computing system can generate multiple language outputs 714 and display the language outputs 714 to the user within the interface 700. Each language output 714 can be generated iteratively based on different identified documents, document blocks, combinations of identified document blocks, etc.

[0102] Figure 7D An example user interface 700, representing some implementations of this disclosure, is depicted interacting with a large language model to request the model to perform a simplification task. Specifically, in some implementations, the computational system can automatically determine, rather than selecting task elements, to use the machine learning large language model to perform a specific task. For example, the computational system can determine a complexity metric (e.g., a term frequency-inverse document frequency (TF-IDF) metric, a metric generated using a complexity classification model, etc.) that describes the complexity associated with the identified blocks of document 402C. Based on determining that the complexity metric is greater than a threshold complexity, the computational system can select a simplification task from multiple tasks for the machine learning large language model. The computational system can process the identified document blocks from document 402C using the machine learning large language model to generate a language output 716, which is a simplified language output of the identified document blocks. In some implementations, the computational system can replace the language output with the simplified language output within the user interface.

[0103] Figure 8 Various interface layouts that can be implemented according to some implementations of this disclosure to realize the interface shown in the foregoing figures are depicted. More generally, attention should be paid broadly to the following regarding... Figures 4 to 7D The interface described is for demonstration purposes only, illustrating how to facilitate user interaction with large language models. However, such interfaces can be implemented using any type or approach in terms of layout, design, interface elements, applications, etc.

[0104] As a specific example Figure 8The diagram illustrates the interface of a web application where a user can input data into a text editing interface 802. For example, text editing interface 802 could be an interface for a word processing application, allowing the user to input text content into the application. As another example, text editing interface 802 could be an interface allowing the user to input text into spreadsheet applications, presentation applications, calendar applications, instant messaging applications, database applications, social media applications, game applications, etc.

[0105] In some implementations, Figures 4 to 7D The interface can be located within some or all of interface positions 804, 806, 808, 810, and 812. For example, Figures 4 to 6B The interface 400 can be located within the interface position 806 (for example, allowing users to manipulate a subset of documents by adding, deleting, reordering, etc.). Figures 7A to 7D The interface 700 can be implemented in any one of the interface positions 804, 808, 810 and 812, or it can be distributed among multiple interface positions.

[0106] As a specific example Figure 6A The query field 606 can be implemented in interface location 810. The language output of the machine learning large language model can be presented and stored / indexed in interface location 808. Identified document blocks in the 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 implementations can be modified within a separate interface accessible from interface location 814 (e.g., a separate tab of the current interface).

[0107] Therefore, it should be broadly understood that the implementations of this disclosure are not limited to the specific interface implementations shown herein. Rather, the implementations described herein that facilitate semantic exploration of specified subsets of documents, improve interpretability of large language model interactions, select specific language tasks to enhance user interaction with the large language model, and / or enable dynamic task selection of the large language model can be implemented using any type or manner of user interface.

[0108] Example Method

[0109] Figure 9 A flowchart depicts an example method 900 for performing semantic exploration on a specified subset of multiple documents according to an example embodiment of this disclosure. Although Figure 9 For illustrative and discussion purposes, the steps are described in a specific order, but the method of this disclosure is not limited to the specifically described order or arrangement. Without departing from the scope of this disclosure, the various steps of method 900 may be omitted, rearranged, combined, and / or modified in various ways.

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

[0111] At position 904, the computing system can use a machine learning embedding generative model to generate text embeddings for text queries.

[0112] At point 906, the computing system can access multiple block embeddings generated separately for multiple document blocks of multiple documents by a machine learning embedding generation model. Multiple documents can be organized into multiple document subsets.

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

[0114] At 910, the computing system can perform a similarity search on text embeddings only for block embeddings associated with document blocks included in one or more selected document subsets, wherein the similarity search identifies one or more block embeddings in the block embeddings as semantically similar to the text query.

[0115] At point 912, the computing system can provide one or more document blocks corresponding to one or more block embeddings identified through a similarity search, for display within a user interface. In some implementations, the user interface includes a text editing interface associated with a word processing application. In some implementations, the user interface includes a main text editing field that enables the user to generate a text set, and a text query includes at least a portion of the text set generated by the user through interaction with the main text editing field. In some implementations, the user interface includes a main text editing field that enables the user to generate a text set and a separate query field that allows the user to enter a text query separate from the text set.

[0116] In some implementations, the user interface includes a document subset selection tool that allows the user to provide user input to select one or more selected document subsets from a plurality of document subsets. In some implementations, the document subset selection tool provides a graphical representation of the plurality of document subsets. In some implementations, the document subset selection tool allows the user to apply a set of filtering logic to the plurality of document subsets, wherein the application of the filtering logic selects one or more selected document subsets from the plurality of document subsets.

[0117] In some implementations, the computing system obtains multiple documents, parses the multiple documents into multiple document blocks, and uses a machine learning embedding generative model to generate multiple block embeddings.

[0118] Figure 10 A flowchart depicts an example method 1000 for performing large language model interactions with improved interpretability according to an example embodiment of this disclosure. Although Figure 10 For illustrative and discussion purposes, the steps are described in a specific order, but the method of this disclosure is not limited to the specifically described order or arrangement. Without departing from the scope of this disclosure, the various steps of method 1000 may be omitted, rearranged, combined, and / or modified in various ways.

[0119] At positions 1002 to 1004, the computing system can receive data indicating a text query and use a machine learning embedding generative model to generate a text embedding for the text query, such as regarding... Figure 9 As stated above.

[0120] At point 1006, the computational system can perform a similarity search on the text embeddings for multiple block embeddings generated separately by the machine learning embedding generation model for multiple document blocks of multiple documents. The similarity search identifies one or more of the identified document blocks as semantically similar to the text query.

[0121] In some implementations, before performing a similarity search on the text embeddings against multiple block embeddings generated separately by the machine learning embedding generation model for multiple document blocks of multiple documents, the computational system can access the multiple block embeddings generated separately by the machine learning embedding generation model for multiple document blocks of multiple documents. These multiple documents are organized into multiple document subsets. In some implementations, the computational system can obtain data indicating one or more selected document subsets within the multiple document subsets.

[0122] In some implementations, performing a similarity search on text embeddings may include performing a similarity search on text embeddings only for block embeddings associated with document blocks included in one or more selected subsets of documents. The similarity search identifies one or more identified document blocks from a plurality of document blocks included in one or more selected subsets of documents as semantically similar to the text query.

[0123] At point 1008, the computing system generates a prompt that includes one or more identified document blocks.

[0124] At position 1010, the computing system provides this prompt as input to the machine learning large language model, which then processes it.

[0125] At position 1012, the computing system receives language output generated by a machine learning large language model based on the processing of the prompt.

[0126] At point 1014, the computing system provides language output as output. In some implementations, providing language output as output includes the computing system providing language output for display within a user interface associated with a word processing application. In some implementations, providing language output for display within the user interface further includes the computing system providing attribution information for display within the user interface. The attribution information identifies a document that includes one or more identified document blocks within a subset of documents. In some implementations, the attribution information describes the location of the identified document block within the document. In some implementations, the user interface includes a main text editing field that enables the user of the user interface to generate a text set. A text query includes at least a portion of the text set generated by the user through interaction with the main text editing field. In some implementations, one or more selected document subsets are specified by the user.

[0127] In some implementations, the computing system may receive data instructing a second text query, which includes at least a portion of a second text set generated by the user through interaction with the main text editing field. The second text set responds to language output.

[0128] In some implementations, the computational system may further use a machine learning embedding generation model to generate a second text embedding for the second text query. The computational system may perform a second similarity search on the second text embedding only for block embeddings associated with document blocks included in one or more second document subsets. The second similarity search identifies one or more second-identified document blocks in the document blocks that are semantically similar to the second text query. The computational system may generate a second suggestion that includes one or more second-identified document blocks. The computational system may provide the second suggestion as input to a machine learning large language model and have it processed by the machine learning large language model. The computational system may receive a second language output generated by the machine learning large language model based on the processing of the second suggestion. The computational system may provide the second language output for display within a user interface associated with a text processing application.

[0129] In some implementations, the computational system may obtain information instructing the user to select one or more second document subsets from a plurality of document subsets before performing a second similarity search on the second text embeddings only for block embeddings associated with document blocks included in one or more second document subsets. In some implementations, the user interface includes a document subset selection tool that allows the user to provide user input to select one or more selected document subsets from a plurality of document subsets. In some implementations, the document subset selection tool provides a graphical representation of the plurality of document subsets. In some implementations, the document subset selection tool allows the user to apply a set of filtering logic to the plurality of document subsets. The application of the filtering logic selects one or more selected document subsets from the plurality of document subsets.

[0130] In some implementations, the computational system may select one or more second document subsets from multiple document subsets, at least in part, based on a user-generated second text set, before performing a second similarity search on the second text embeddings only for the block embeddings associated with document blocks included in one or more second document subsets.

[0131] Figure 11 A flowchart depicts an example method 1100, which, according to an example embodiment of this disclosure, facilitates the selection of a specific language task to enhance user interaction with a large language model. Although Figure 11 For illustrative and discussion purposes, the steps are described in a specific order, but the method of this disclosure is not limited to the specifically described order or arrangement. Without departing from the scope of this disclosure, the various steps of method 1100 may be omitted, rearranged, combined, and / or modified in various ways.

[0132] At 1102, the computing system can obtain user interaction information. The user interaction information may indicate: (a) a text query comprising at least a portion of a text set generated by the user through interaction with a text editing field of a user interface, wherein the user interface includes a text editing field and multiple optional task elements associated with multiple tasks of a machine learning large language model; and (b) a selected task element chosen by the user from the multiple optional text elements.

[0133] At 1104, the computing system can use a machine learning embedding generative model to generate text embeddings for text queries.

[0134] At point 1106, the computational system performs a similarity search on the text embeddings for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents. The similarity search identifies one or more of the identified document blocks as semantically similar to the text query.

[0135] In some implementations, before performing a similarity search on the text embeddings for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, wherein the multiple documents are organized into multiple document subsets, the computing system may access multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents. The computing system may obtain data indicating one or more selected document subsets from the multiple document subsets. In some implementations, obtaining data indicating one or more selected document subsets may include obtaining data indicating the selection of one or more selected document subsets from the multiple document subsets via user interaction with a user interface.

[0136] In some implementations, performing a similarity search on a text embedding may include performing a similarity search on the text embedding only for block embeddings associated with document blocks included in one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in one or more selected document subsets as semantically similar to the text query.

[0137] At 1108, the computing system can use a machine learning large language model to process prompts based on one or more identified document blocks to perform a task associated with a selected task element in a multi-task process.

[0138] At 1110, the computing system can obtain the language output generated by the machine learning large language model based on the processing of the prompt.

[0139] In some implementations, the computing system may provide language output for display within a user interface associated with a word processing application. In some implementations, providing language output for display within the user interface may further include providing attribution information for display within the user interface, wherein the attribution information identifies a document within one or more subsets of documents that includes one or more identified document blocks.

[0140] In some implementations, a text query may include a second text query received after a previous text query, wherein the second text query is a response to a previous language output based on the previous text query.

[0141] In some implementations, the selected task element is associated with an idea extension task among multiple tasks, and one or more identified document blocks include multiple identified document blocks. Using a machine learning large language model to process cues based on one or more identified document blocks to perform a task may include: for multiple iterations, a computational system processes new cues to obtain updated language output, wherein the new cues are based on one or more of the following: (a) a subset of identified document blocks from multiple identified document blocks, or (b) previously updated language output.

[0142] In some implementations, the selected task element is associated with a summary task among multiple tasks. Using a machine learning large language model to process prompts based on one or more identified document blocks to perform a task may include: using the machine learning large language model to process prompts based on one or more identified document blocks to obtain language output, wherein the language output includes a summary of the one or more identified document blocks.

[0143] In some implementations, the selected task element is associated with a simplified task among multiple tasks. Using a machine learning large language model to process prompts based on one or more identified document blocks to perform a task may include: using the machine learning large language model to process prompts based on one or more identified document blocks to obtain language output. The computing system can use the machine learning large language model to generate simplified language output, which is a simplified representation describing the language output.

[0144] In some implementations, selected task elements are associated with opposing viewpoint tasks among multiple tasks. Using a machine learning large language model to process cues based on one or more identified document blocks to perform a task may include: using the machine learning large language model to process cues based on one or more identified document blocks to obtain language output. The language output describes a viewpoint. The computational system can use the machine learning large language model to generate a second language output describing a second viewpoint opposite to that viewpoint.

[0145] Figure 12A flowchart depicts an example method 1200 for performing dynamic task selection on a large language model according to an example embodiment of the present disclosure. Although Figure 12 For illustrative and discussion purposes, the steps are described in a specific order, but the method of this disclosure is not limited to the specifically described order or arrangement. Without departing from the scope of this disclosure, the various steps of method 1200 may be omitted, rearranged, combined, and / or modified in various ways.

[0146] At 1202, the computing system can obtain user interaction information indicating a text query, which includes at least a portion of a text set generated by the user through interaction with text editing fields of the user interface.

[0147] At 1204, the computing system can use a machine learning embedding generative model to generate text embeddings for text queries.

[0148] At point 1206, the computational system can perform a similarity search on the text embeddings for multiple block embeddings generated separately by the machine learning embedding generation model for multiple document blocks of multiple documents. The similarity search identifies one or more of the identified document blocks as semantically similar to the text query.

[0149] At 1208, the computing system can select the first task among multiple tasks for the machine learning large language model, based at least in part on the text query or at least one of the one or more identified document blocks.

[0150] At 1210, the computing system can use a machine learning large language model to process prompts based on one or more identified document blocks to perform the first task among multiple tasks associated with the selected task element.

[0151] At point 1212, the computing system can obtain the language output generated by the machine learning large language model based on the processing of the prompt.

[0152] Additional Public Content

[0153] This paper discusses technologies related to servers, databases, software applications, and other computer-based systems, as well as the actions taken and the information sent to and from such systems. The inherent flexibility of computer-based systems allows for a wide range of possible configurations, combinations, and divisions of tasks and functions between and within components. For example, the processes discussed herein can be implemented using a single device or component, or multiple devices or components working in combination. Databases and applications can be implemented on a single system or distributed across multiple systems. Distributed components can operate sequentially or in parallel.

[0154] While the subject matter has been described in detail with respect to various specific example embodiments, each example is provided by way of illustration and not limitation. Modifications, variations, and equivalents to such embodiments will be readily apparent to those skilled in the art upon understanding the foregoing. Therefore, this disclosure does not exclude such modifications, variations, and / or additions to the subject matter that will be readily understood by those of ordinary skill in the art. For example, features shown or described as part of an embodiment may be used with another embodiment to produce further embodiments. Therefore, this disclosure is intended to cover such modifications, variations, and equivalents.

[0155] Implementation

[0156] The following implementations include a subset of the many implementations described herein. While the processes in the figures may illustrate a particular order of operations performed by certain implementations of this disclosure, it should be understood that such order is exemplary (e.g., alternative implementations may perform operations in a different order, combine certain operations, overlap certain operations, etc.).

[0157] Implementation 1: A computer-implemented method for semantic exploration of a specified subset of multiple documents, the method comprising:

[0158] • Data indicating a text query is received by a computing system comprising one or more computing devices;

[0159] • The computational system generates the text embedding of the text query using a machine learning embedding generation model;

[0160] • The computing system accesses multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of the multiple documents, wherein the multiple documents are organized into multiple document subsets;

[0161] • The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets;

[0162] • The computing system performs a similarity search on the text embeddings only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more block embeddings among the block embeddings as semantically similar to the text query; and

[0163] • The computing system provides one or more document blocks corresponding to one or more block embeddings among the multiple document blocks identified through the similarity search, for display within the user interface.

[0164] Implementation Method 2: The computer-implemented method according to Implementation Method 1, wherein the user interface includes a text editing interface associated with a word processing application.

[0165] Implementation method 3: The computer-implemented method according to implementation method 2, wherein:

[0166] • The user interface includes a main text editing field that enables the user to generate text sets; and

[0167] • The text query includes at least a portion of the text set generated by the user through interaction with the main text editing field.

[0168] Implementation 4: The computer-implemented method according to Implementation 2, wherein the user interface includes:

[0169] • Enables the user to generate the main text editing field for the text set; and

[0170] • A query field separate from the main text editing field, which allows the user to enter a text query separate from the text set.

[0171] Implementation 5: A computer-implemented method according to any of the foregoing implementations, wherein the one or more selected document subsets are specified by the user.

[0172] Implementation method 6: The computer-implemented method according to implementation method 5, wherein the user interface includes a document subset selection tool that enables the user to provide user input to select one or more selected document subsets from the plurality of document subsets.

[0173] Implementation method 7: The computer-implemented method according to implementation method 6, wherein the document subset selection tool provides a graphical representation of the plurality of document subsets.

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

[0175] Implementation 9: A computer-implemented method according to any of the foregoing implementations, wherein at least some of the documents included in the one or more selected document subsets include documents provided by the user.

[0176] Implementation 10: A computer-implemented method according to any of the foregoing implementations, wherein at least some documents included in the one or more selected document subsets include:

[0177] • Books;

[0178] • Product manual;

[0179] • Legal advice;

[0180] • Academic papers;

[0181] • Proprietary data files; or

[0182] • Patent documents.

[0183] Implementation 11: The computer-implemented method according to any of the foregoing implementations further includes:

[0184] • The multiple documents are obtained by the computing system;

[0185] • The computing system parses the plurality of documents into the plurality of document blocks; and

[0186] • The computing system generates the plurality of block embeddings using the machine learning embedding generation model.

[0187] Implementation 12: A computer system for semantic exploration of a specified subset of multiple documents, the computer system comprising:

[0188] • One or more processors; and

[0189] • One or more non-transitory computer-readable media, which together store:

[0190] ○ Access multiple block embeddings generated by a machine learning embedding generation model for multiple document blocks of the multiple documents, wherein the multiple documents are organized into multiple document subsets; and

[0191] ○ Instructions, which, when executed by the one or more processors, cause the computer system to perform operations, including:

[0192] ▪ Data indicating a text query is received by a computing system comprising one or more computing devices;

[0193] ▪ The computing system uses the machine learning embedding generation model to generate the text embedding for the text query;

[0194] ▪ The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets;

[0195] ▪ The computing system performs a similarity search on the text embeddings only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more block embeddings in the block embeddings as semantically similar to the text query; and

[0196] ▪ The computing system provides one or more document blocks corresponding to one or more block embeddings among the multiple document blocks identified through the similarity search, for display within the user interface.

[0197] Implementation 13: The computer system according to implementation 12, wherein the user interface includes a text editing interface associated with a word processing application.

[0198] Implementation 14: The computer system according to Implementation 13, wherein:

[0199] • The user interface includes a main text editing field that enables the user to generate text sets; and

[0200] • The text query includes at least a portion of the text set generated by the user through interaction with the main text editing field.

[0201] Implementation 15: The computer system according to Implementation 13, wherein the user interface includes:

[0202] • Enables the user to generate the main text editing field for the text set; and

[0203] • A query field separate from the main text editing field, which allows the user to enter a text query separate from the text set.

[0204] Implementation 16: A computer system according to any one of implementations 12 to 15, wherein the one or more selected document subsets are specified by the user.

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

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

[0207] Implementation 19: The computer system according to Implementation 17 or 18, wherein the document subset selection tool enables the user to apply a set of filtering logic to the plurality of document subsets, wherein the application of the filtering logic selects one or more selected document subsets from the plurality of document subsets.

[0208] Implementation 20: A computer system according to any one of implementations 12 to 19, wherein the operation further includes:

[0209] • The multiple documents are obtained by the computing system;

[0210] • The computing system parses the plurality of documents into the plurality of document blocks; and

[0211] • The computing system generates the plurality of block embeddings using the machine learning embedding generation model.

[0212] Implementation 21: A method for a computer-based implementation of large language model interaction with improved interpretability, the method comprising:

[0213] • Data indicating a text query is received by a computing system comprising one or more computing devices;

[0214] • The computational system generates the text embedding of the text query using a machine learning embedding generation model;

[0215] • The computing system performs a similarity search on the text embeddings for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query;

[0216] • The computing system generates a prompt that includes one or more of the identified document blocks;

[0217] • The computational system provides the prompt as input to the machine learning large language model, which then processes it.

[0218] • The computing system receives language output generated by the machine learning large language model based on the processing of the prompts; and

[0219] • The language output is provided as output by the computing system.

[0220] Implementation 22: The computer-implemented method according to Implementation 21, wherein before performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, the method includes the computing system accessing the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets.

[0221] Implementation 23: The computer-implemented method according to Implementation 22, wherein accessing the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks further includes obtaining data by the computing system indicating one or more selected document subsets of the plurality of document subsets.

[0222] Implementation 24: The computer-implemented method according to Implementation 23, wherein performing the similarity search on the text embedding includes the computing system performing a similarity search on the text embedding only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0223] Implementation 25: The computer-implemented method according to Implementation 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 word processing application.

[0224] Implementation 26: A computer-implemented method according to Implementation 25, wherein providing the language output for display within the user interface further includes providing attribution information by the computing system for display within the user interface, wherein the attribution information identifies a document in the one or more selected document subsets that includes an identified document block from the one or more identified document blocks.

[0225] Implementation 27: The computer-implemented method according to Implementation 26, wherein the attribution information describes the location of the identified document block within the document.

[0226] Implementation 28: A computer-implemented method according to Implementation 25, wherein the user interface includes a main text editing field that enables a user of the user interface to generate a text set, and the text query includes at least a portion of the text set generated by the user through interaction with the main text editing field.

[0227] Implementation 29: The computer-implemented method according to Implementation 28, wherein the one or more selected subsets of documents are specified by the user.

[0228] Implementation 30: A computer-implemented method according to any one of implementations 28 to 29, wherein the method further includes receiving data by the computing system instructing a second text query, the second text query including at least a portion of a second text set generated by the user through interaction with the main text editing field, wherein the second text set is in response to the language output.

[0229] Implementation 31: The computer-implemented method according to Implementation 30, wherein the method further includes:

[0230] • The computing system uses the machine learning embedding generation model to generate a second text embedding for the second text query;

[0231] • The computing system performs a second similarity search on the second text embedding only for the block embedding associated with a document block included 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 blocks included in the document block of the document block as semantically similar to the second text query;

[0232] • The computing system generates a second prompt that includes one or more of the second identified document blocks;

[0233] • The computing system provides the second prompt as input to the second machine learning large language model, which then processes it.

[0234] • The computing system receives the second language output generated by the machine learning large language model based on the processing of the second prompt; and

[0235] • The computing system provides the second language output for display within the user interface associated with the text processing application.

[0236] Implementation 32: A computer-implemented method according to Implementation 31, wherein before performing the second similarity search on the second text embedding only for the block embedding associated with the document block included in the one or more second document subsets, the method includes obtaining information from the computing system instructing the user to select the one or more second document subsets from the plurality of document subsets.

[0237] Implementation 33: The computer-implemented method according to Implementation 32, wherein the user interface includes a document subset selection tool that enables the user to provide user input to select one or more selected document subsets from the plurality of document subsets.

[0238] Implementation 34: The computer-implemented method according to Implementation 33, wherein the document subset selection tool provides a graphical representation of the plurality of document subsets.

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

[0240] Implementation 36: A computer-implemented method according to implementation 31, wherein before performing the second similarity search on the second text embedding only for the block embedding associated with the document block included 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 second text set generated by the user.

[0241] Implementation 37: A computer system for interaction of large language models with improved interpretability, the computer system comprising:

[0242] • One or more processors; and

[0243] • One or more non-transitory computer-readable media, the one or more non-transitory computer-readable media collectively storing instructions, the instructions causing the computer system to perform operations when executed by the one or more processors, the operations including:

[0244] ○ Receive data queried from the instruction text;

[0245] ○ Use a machine learning embedding generative model to generate the text embedding for the text query;

[0246] ○ For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, perform a similarity search on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query;

[0247] ○ Generate a prompt that includes one or more of the identified document blocks;

[0248] ○ The prompt is provided as input to the machine learning large language model and processed by the machine learning large language model;

[0249] ○ Receive language output generated by the machine learning large language model based on the processing of the prompts; and

[0250] ○ Provide the language output as output.

[0251] Implementation 38: The computer system according to Implementation 37, wherein before performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, the operation includes accessing the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets.

[0252] Implementation 39: The computer system according to Implementation 38, wherein accessing the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks respectively includes obtaining data indicating one or more selected document subsets of the plurality of document subsets.

[0253] Implementation 40: One or more non-transitory computer-readable media storing instructions that, when executed by one or more processors of a computing system, cause the computing system to perform operations, the operations including:

[0254] • Receive data from the query instruction text;

[0255] • Use a machine learning embedding generation model to generate the text embedding for the text query;

[0256] • For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, perform a similarity search on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query;

[0257] • Generate a prompt that includes one or more of the identified document blocks;

[0258] • The prompt is provided as input to the machine learning large language model and processed by the machine learning large language model;

[0259] • Receive language output generated by the machine learning large language model based on the processing of the prompts; and

[0260] • Provide the language output as output.

[0261] Implementation 41: A computer-implemented method for facilitating the selection of specific language tasks to enhance user interaction with a large language model, the method comprising:

[0262] • User interaction information instructing the following is obtained by a computing system comprising one or more computing devices:

[0263] ○ A text query, comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface, wherein the user interface includes the text editing field and multiple optional task elements respectively associated with multiple tasks of a machine learning large language model; and

[0264] ○ The selected task element chosen by the user from multiple optional task elements;

[0265] • The computational system generates the text embedding of the text query using a machine learning embedding generation model;

[0266] • The computing system performs a similarity search on the text embeddings for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query;

[0267] • The computing system uses the machine learning large language model to process prompts based on the one or more identified document blocks to perform a task associated with the selected task element among the plurality of tasks; and

[0268] • The computing system obtains the language output generated by the machine learning large language model based on the processing of the prompts.

[0269] Implementation 42: A computer-implemented method according to Implementation 41, wherein before performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, the method includes the computing system accessing the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets, and the computing system obtaining data indicating one or more selected document subsets in the plurality of document subsets.

[0270] Implementation 43: The computer-implemented method according to Implementation 42, wherein obtaining the data indicating the one or more selected document subsets includes obtaining data by the computing system indicating the selection of one or more selected document subsets from the plurality of document subsets via interaction between the user and the user interface.

[0271] Implementation 44: A computer-implemented method according to any one of Implementations 42 to 43, wherein performing the similarity search on the text embedding comprises the computing system performing a similarity search on the text embedding only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0272] Implementation 45: A computer-implemented method according to Implementation 44, wherein the method further includes the computing system providing the language output for display within a user interface associated with a word processing application.

[0273] Implementation 46: The computer-implemented method according to Implementation 45, wherein providing the language output to display within the user interface further includes providing attribution information by the computing system to display within the user interface, wherein the attribution information identifies a document in the one or more selected document subsets that includes an identified document block from the one or more identified document blocks.

[0274] Implementation 47: A computer-implemented method according to any one of implementations 41 to 46, wherein the text query includes a second text query received after a previous text query, and wherein the second text query is a response to a previous language output based on the previous text query.

[0275] Implementation 48: A computer-implemented method according to any one of Implementations 41 to 47, wherein the selected task element is associated with a thought expansion task among the plurality of tasks, and wherein the one or more identified document blocks comprise a plurality of identified document blocks; and wherein processing the prompts based on the one or more identified document blocks using the machine learning large language model to perform the task comprises: for multiple iterations, processing new prompts by the computing system to obtain updated language output, wherein the new prompts are based on one or more of: (a) a subset of the identified document blocks of the plurality of identified document blocks, or (b) previously updated language output.

[0276] Implementation 49: A computer-implemented method according to any one of implementations 41 to 47, wherein the selected task element is associated with a summary task among the plurality of tasks; and wherein processing the prompts based on the one or more identified document blocks using the machine learning large language model to perform the task comprises: the computing system using the machine learning large language model to process the prompts based on the one or more identified document blocks to obtain the language output, wherein the language output includes a summary of the one or more identified document blocks.

[0277] Implementation 50: A computer-implemented method according to any one of implementations 41 to 47, wherein the selected task element is associated with a simplified task among the plurality of tasks; and wherein processing the prompts based on the one or more identified document blocks using the machine learning large language model to perform the task includes:

[0278] • The computing system processes the cues based on the one or more identified document blocks using the machine learning large language model to obtain the language output; and

[0279] • The computing system uses the machine learning large language model to generate a simplified language output that describes a simplified representation of the language output.

[0280] Implementation 51: A computer-implemented method according to any one of implementations 41 to 47, wherein the selected task element is associated with an opposing viewpoint task among the plurality of tasks; and wherein processing the cues based on the one or more identified document blocks using the machine learning large language model to perform the task includes:

[0281] • The computing system processes the cues based on the one or more identified document blocks using the machine learning large language model to obtain the language output, wherein the language output describes an opinion; and

[0282] • The computing system uses the machine learning large language model to generate a second language output describing a second viewpoint that is contrary to the stated viewpoint.

[0283] Implementation 52: A computer system for facilitating the selection of specific language tasks to enhance user interaction with a large language model, the computer system comprising:

[0284] • One or more processors; and

[0285] • One or more non-transitory computer-readable media, the one or more non-transitory computer-readable media collectively storing instructions, the instructions causing the computer system to perform operations when executed by the one or more processors, the operations including:

[0286] ○ Obtain user interaction information instructing the following:

[0287] ▪ A text query comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface, wherein the user interface includes the text editing field and multiple optional task elements respectively associated with multiple tasks of a machine learning large language model; and

[0288] ▪ The selected task element chosen by the user from multiple optional task elements;

[0289] ○ Use a machine learning embedding generative model to generate the text embedding for the text query;

[0290] ○ For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, perform a similarity search on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query;

[0291] ○ Using the machine learning large language model to process prompts based on the one or more identified document blocks to perform a task associated with the selected task element among the plurality of tasks; and

[0292] ○ Obtain the language output generated by the machine learning large language model based on the processing of the prompts.

[0293] Implementation 53: The computer system according to Implementation 52, wherein before performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, the operation includes:

[0294] • Access the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks, wherein the plurality of documents are organized into a plurality of document subsets; and

[0295] • Obtain data indicating one or more selected document subsets from the plurality of document subsets.

[0296] Implementation 54: The computer system according to Implementation 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 via interaction between the user and the user interface.

[0297] Implementation 55: The computer system according to Implementation 53, wherein performing the similarity search on the text embedding includes performing a similarity search on the text embedding only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0298] Implementation 56: The computer system according to Implementation 55, wherein the operation further includes providing the language output for display within a user interface associated with a word processing application; and wherein providing the language output for display within the user interface further includes providing attribution information for display within the user interface, wherein the attribution information identifies a document in the one or more selected document subsets that includes an identified document block from the one or more identified document blocks.

[0299] Implementation 57: A computer system according to any one of implementations 52 to 56, wherein the text query includes a second text query received after a previous text query, and wherein the second text query is a response to a previous language output based on the previous text query.

[0300] Implementation 58: A computer system according to any one of Implementations 52 to 56, wherein the selected task element is associated with a thought expansion task among the plurality of tasks, and wherein the one or more identified document blocks include a plurality of identified document blocks; and wherein processing the cues based on the one or more identified document blocks to perform the task using the machine learning large language model comprises: for multiple iterations, processing cues based on different subsets of the plurality of identified document blocks to obtain corresponding plurality of outputs, wherein the language outputs include at least some of the plurality of outputs.

[0301] Implementation 59: A computer system according to any one of implementations 52 to 56, wherein the selected task element is associated with a summary task among the plurality of tasks; and wherein processing the prompts based on the one or more identified document blocks using the machine learning large language model to perform the task includes:

[0302] • Process the prompts based on the one or more identified document blocks using the machine learning large language model to obtain the language output; and

[0303] • Use the machine learning large language model to generate a summary of the language output.

[0304] Implementation 60: One or more non-transitory computer-readable media storing instructions that, when executed by one or more processors of a computing system, cause the computing system to perform operations, the operations including:

[0305] • Obtain user interaction information that instructs the following:

[0306] ○ A text query, comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface, wherein the user interface includes the text editing field and multiple optional task elements respectively associated with multiple tasks of a machine learning large language model; and

[0307] ○ The selected task element chosen by the user from multiple optional task elements;

[0308] • Use a machine learning embedding generation model to generate the text embedding for the text query;

[0309] • For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, perform a similarity search on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query;

[0310] • Use the machine learning large language model to process prompts based on one or more identified document blocks to perform a task associated with the selected task element among the plurality of tasks; and

[0311] • Obtain the language output generated by the machine learning large language model based on the processing of the prompts.

[0312] Implementation 61: A computer-based method for dynamic task selection in large language models, the method comprising:

[0313] • User interaction information indicating a text query is obtained by a computing system including one or more computing devices, the text query including at least a portion of a text set generated by a user through interaction with a text editing field of a user interface;

[0314] • The computational system generates the text embedding of the text query using a machine learning embedding generation model;

[0315] • The computing system performs a similarity search on the text embeddings for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query;

[0316] • The computing system selects a first task from a plurality of tasks for a machine learning large language model, based at least in part on the text query or at least one of the one or more identified document blocks; and

[0317] • The computing system uses the machine learning large language model to process prompts based on the one or more identified document blocks to perform the first task among the plurality of tasks; and

[0318] • The computing system obtains the language output generated by the machine learning large language model based on the processing of the prompts.

[0319] Implementation 62: The computer-implemented method according to Implementation 61, wherein before performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, the method includes:

[0320] • Access by the computing system to the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks, wherein the plurality of documents are organized into a plurality of document subsets; and

[0321] • The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets.

[0322] Implementation 63: The computer-implemented method according to Implementation 62, wherein obtaining the data indicating the one or more selected document subsets includes obtaining data by the computing system indicating the selection of one or more selected document subsets from the plurality of document subsets via interaction between the user and the user interface.

[0323] Implementation 64: A computer-implemented method according to any one of Implementations 62 to 63, wherein performing the similarity search on the text embedding comprises the computing system performing a similarity search on the text embedding only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0324] Implementation 65: A computer-implemented method according to Implementation 64, wherein the method further includes the computing system providing the language output for display within a user interface associated with a word processing application.

[0325] Implementation 66: A computer-implemented method according to Implementation 65, wherein providing the language output for display within the user interface further includes providing attribution information by the computing system for display within the user interface, wherein the attribution information identifies a document in the one or more selected document subsets that includes an identified document block from the one or more identified document blocks.

[0326] Implementation 67: A computer-implemented method according to any one of implementations 61 to 66, wherein the text query includes a second text query received after a previous text query, and wherein the second text query is a response to a previous language output based on the previous text query.

[0327] Implementation 68: A computer-implemented method according to any one of implementations 61 to 67, wherein selecting the first task among the plurality of tasks for the machine learning large language model based at least in part on the text query or the at least one of the one or more identified document blocks includes:

[0328] • The computing system determines a complexity measure that describes the degree of complexity associated with the text query and / or the one or more identified document blocks;

[0329] • The computational system determines that the complexity metric is greater than a threshold complexity; and

[0330] • The computing system selects a simplified task from the plurality of tasks for the machine learning large language model based on the determination result.

[0331] Implementation 69: The computer-implemented method according to Implementation 68, wherein processing the prompts based on the one or more identified document blocks using the machine learning large language model to perform the task includes:

[0332] • The computing system processes the cues based on the one or more identified document blocks using the machine learning large language model to obtain the language output; and

[0333] • The computing system uses the machine learning large language model to generate a simplified language output that describes a simplified representation of the language output.

[0334] Implementation 70: A computer-implemented method according to implementation 69, wherein the method further includes: the computing system displaying the simplified language output adjacent to the language output within the user interface.

[0335] Implementation 71: A computer-implemented method according to implementation 69, wherein the method further includes: the computing system displaying the simplified language output in a second user interface different from the user interface.

[0336] Implementation 72: A computer-implemented method according to Implementation 69, wherein the method further includes: the computing system displaying the simplified language output within the user interface to replace the language output.

[0337] Implementation 73: A computer-implemented method according to any one of implementations 61 to 67, wherein selecting the first task among the plurality of tasks for the machine learning large language model based at least in part on the text query or the at least one of the one or more identified document blocks includes:

[0338] • The computing system determines that the text query and / or one or more identified document blocks include text content expressing opinions; and

[0339] • The computing system selects opposing viewpoint tasks from among the multiple tasks for the machine learning large language model based on the determined results.

[0340] Implementation 74: The computer-implemented method according to Implementation 73, wherein processing the prompts based on the one or more identified document blocks using the machine learning large language model to perform the task includes:

[0341] • The computing system processes the cues based on the one or more identified document blocks using the machine learning large language model to obtain the language output, wherein the language output describes an opinion; and

[0342] • The computing system uses the machine learning large language model to generate a second language output describing a second viewpoint that is contrary to the stated viewpoint.

[0343] Implementation 75: A computer-implemented method according to any one of Implementations 61 to 67, wherein the first task is a thought expansion task, wherein the one or more identified document blocks comprise a plurality of identified document blocks; and wherein processing the prompts based on the one or more identified document blocks using the machine learning large language model to perform the task comprises: for multiple iterations, processing new prompts by the computing system to obtain updated language output, wherein the new prompts are based on one or more of: (a) a subset of the identified document blocks of the plurality of identified document blocks, or (b) previously updated language output.

[0344] Implementation 76: A computer system for dynamic task selection in large language models, the computer system comprising:

[0345] • One or more processors; and

[0346] • One or more non-transitory computer-readable media, the one or more non-transitory computer-readable media collectively storing instructions, the instructions causing the computer system to perform operations when executed by the one or more processors, the operations including:

[0347] • Obtain user interaction information indicating a text query, the text query comprising at least a portion of a text set generated by the user through interaction with text editing fields of a user interface; and

[0348] • Use a machine learning embedding generation model to generate the text embedding for the text query;

[0349] • For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, perform a similarity search on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query;

[0350] • Select a first task among multiple tasks for a machine learning large language model, based at least in part on the text query or at least one of one or more identified document blocks; and

[0351] • Use the machine learning large language model to process prompts based on the one or more identified document blocks to perform the first task of the plurality of tasks; and

[0352] • Obtain the language output generated by the machine learning large language model based on the processing of the prompts.

[0353] Implementation 77: The computer system according to Implementation 76, wherein before performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, the operation includes:

[0354] • Access the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks, wherein the plurality of documents are organized into a plurality of document subsets; and

[0355] • Obtain data indicating one or more selected document subsets from the plurality of document subsets.

[0356] Implementation 78: The computer system according to Implementation 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 the plurality of document subsets via interaction between the user and the user interface.

[0357] Implementation 79: A computer system according to any one of Implementations 77 to 78, wherein performing the similarity search on the text embedding comprises performing a similarity search on the text embedding only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0358] Implementation 80: One or more non-transitory computer-readable media storing instructions that, when executed by one or more processors of a computing system, cause the computing system to perform operations, the operations including:

[0359] • Obtain user interaction information indicating a text query, the text query comprising at least a portion of a text set generated by the user through interaction with text editing fields of a user interface; and

[0360] • Use a machine learning embedding generation model to generate the text embedding for the text query;

[0361] • For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, perform a similarity search on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query;

[0362] • Select a first task among multiple tasks for a machine learning large language model, based at least in part on the text query or at least one of one or more identified document blocks; and

[0363] • Use the machine learning large language model to process prompts based on the one or more identified document blocks to perform the first task of the plurality of tasks; and

[0364] • Obtain the language output generated by the machine learning large language model based on the processing of the prompts.

Claims

1. A computer-implemented method for facilitating the selection of specific language tasks to enhance user interaction with a large language model, the method comprising: User interaction information instructing the following is obtained by a computing system comprising one or more computing devices: (a) 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 optional task elements associated with a plurality of tasks of a machine learning large language model, respectively; as well as (b) The selected task element chosen by the user from the plurality of optional task elements; The computing system generates the text embedding of the text query using a machine learning embedding generation model; The computing system performs a similarity search on the text embeddings for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query; The computing system uses the machine learning large language model to process prompts based on one or more identified document blocks to perform a task associated with the selected task element among the plurality of tasks; as well as The computing system obtains the language output generated by the machine learning large language model based on the processing of the prompts.

2. The computer-implemented method of claim 1, wherein before performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, the method comprises: The computing system accesses the multiple block embeddings generated by the machine learning embedding generation model for the multiple document blocks of the multiple documents, wherein the multiple documents are organized into multiple document subsets; as well as The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets.

3. The computer-implemented method of claim 2, wherein obtaining the data indicating the one or more selected document subsets comprises obtaining data by the computing system indicating the selection of one or more selected document subsets from the plurality of document subsets via interaction between the user and the user interface.

4. The computer-implemented method according to any one of claims 2 to 3, wherein performing the similarity search on the text embedding comprises: The computing system performs a similarity search on the text embedding only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in the one or more selected document subsets as semantically similar to the text query.

5. The computer-implemented method of claim 4, wherein the method further comprises the computing system providing the language output for display within a user interface associated with a word processing application.

6. The computer-implemented method of claim 5, wherein providing the language output for display within the user interface further includes providing attribution information by the computing system for display within the user interface, wherein the attribution information identifies a document in the one or more selected document subsets that includes an identified document block from the one or more identified document blocks.

7. The computer-implemented method according to any one of claims 1 to 6, wherein the text query includes a second text query received after a previous text query, and wherein the second text query is a response to a previous language output based on the previous text query.

8. The computer-implemented method according to any one of claims 1 to 7, wherein the selected task element is associated with the idea expansion task among the plurality of tasks, and wherein the one or more identified document blocks comprise a plurality of identified document blocks; and The process of using the machine learning large language model to process the prompts based on the one or more identified document blocks to perform the task includes: For multiple iterations, the computing system processes new prompts to obtain updated language output, wherein the new prompts are based on one or more of the following: (a) a subset of the identified document blocks of the plurality of identified document blocks, or (b) the previously updated language output.

9. The computer-implemented method according to any one of claims 1 to 7, wherein the selected task element is associated with a summary task among the plurality of tasks; and The process of using the machine learning large language model to process the prompts based on the one or more identified document blocks to perform the task includes: The computing system uses the machine learning large language model to process the prompts based on the one or more identified document blocks to obtain the language output, wherein the language output includes a summary of the one or more identified document blocks.

10. The computer-implemented method according to any one of claims 1 to 7, wherein the selected task element is associated with a simplified task among the plurality of tasks; and The process of using the machine learning large language model to process the prompts based on the one or more identified document blocks to perform the task includes: The computing system uses the machine learning large language model to process the prompts based on the one or more identified document blocks to obtain the language output; as well as The computing system uses the machine learning large language model to generate a simplified language output that describes a simplified representation of the language output.

11. The computer-implemented method according to any one of claims 1 to 7, wherein the selected task element is associated with an opposing viewpoint task among the plurality of tasks; and The process of using the machine learning large language model to process the prompts based on the one or more identified document blocks to perform the task includes: The computing system processes the cues based on the one or more identified document blocks using the machine learning large language model to obtain the language output, wherein the language output describes an opinion; and The computing system uses the machine learning large language model to generate a second language output describing a second viewpoint that is contrary to the stated viewpoint.

12. A computer system for facilitating the selection of specific language tasks to enhance user interaction with a large language model, the computer system comprising: One or more processors; as well as One or more non-transitory computer-readable media, the one or more non-transitory computer-readable media collectively storing instructions, the instructions causing the computer system to perform operations when executed by the one or more processors, the operations including: Obtain user interaction information that instructs the following: (a) A text query comprising at least a portion of a text set generated by a user through interaction with a text editing field of a user interface, wherein the user interface includes the text editing field and multiple optional task elements respectively associated with multiple tasks of a machine learning large language model; and (b) The selected task element chosen by the user from the plurality of optional task elements; The text embedding of the text query is generated using a machine learning embedding generative model; For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, a similarity search is performed on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query; The machine learning large language model is used to process prompts based on one or more identified document blocks to perform a task associated with the selected task element among the plurality of tasks; and Obtain the language output generated by the machine learning large language model based on the processing of the prompts.

13. The computer system of claim 12, wherein before performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, the operation includes: Access the multiple block embeddings generated by the machine learning embedding generation model for the multiple document blocks of the multiple documents, wherein the multiple documents are organized into multiple document subsets; as well as Obtain data indicating one or more selected document subsets from the plurality of document subsets.

14. The computer system of claim 13, 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 via interaction between the user and the user interface.

15. The computer system of claim 13, wherein performing the similarity search on the text embedding comprises: A similarity search is performed on the text embedding only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in the one or more selected document subsets as semantically similar to the text query.

16. The computer system of claim 15, wherein the operation further comprises providing the language output for display within a user interface associated with a word processing application; and Providing the language output for display within the user interface further includes providing attribution information for display within the user interface, wherein the attribution information identifies a document in the one or more selected document subsets that includes an identified document block from the one or more identified document blocks.

17. The computer system according to any one of claims 12 to 16, wherein the text query includes a second text query received after a previous text query, and wherein the second text query is a response to a previous language output based on the previous text query.

18. The computer system according to any one of claims 12 to 16, wherein the selected task element is associated with the idea expansion task among the plurality of tasks, and wherein the one or more identified document blocks comprise a plurality of identified document blocks; and The process of using the machine learning large language model to process the prompts based on the one or more identified document blocks to perform the task includes: For multiple iterations, prompts based on different subsets of the identified document blocks are processed to obtain corresponding multiple outputs, wherein the language outputs include at least some of the multiple outputs.

19. The computer system according to any one of claims 12 to 16, wherein the selected task element is associated with a summary task among the plurality of tasks; and The process of using the machine learning large language model to process the prompts based on the one or more identified document blocks to perform the task includes: The machine learning large language model is used to process the prompts based on one or more identified document blocks to obtain the language output; as well as The machine learning large language model is used to generate a summary of the language output.

20. One or more non-transitory computer-readable media storing instructions that, when executed by one or more processors of a computing system, cause the computing system to perform operations, the operations including: Obtain user interaction information that instructs the following: (a) 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 optional task elements associated with a plurality of tasks of a machine learning large language model, respectively; as well as (b) The selected task element chosen by the user from the plurality of optional task elements; The text embedding of the text query is generated using a machine learning embedding generative model; For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, a similarity search is performed on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query; The machine learning large language model is used to process prompts based on one or more identified document blocks to perform a task associated with the selected task element among the plurality of tasks; as well as Obtain the language output generated by the machine learning large language model based on the processing of the prompts.

21. A computer-implemented method for dynamic task selection in a large language model, the method comprising: User interaction information indicating a text query is obtained by a computing system including one or more computing devices, the text query including at least a portion of a text set generated by the user through interaction with a text editing field of a user interface; The computing system generates the text embedding of the text query using a machine learning embedding generation model; The computing system performs a similarity search on the text embeddings for multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query; The computing system selects a first task from a plurality of tasks for a machine learning large language model, based at least in part on the text query or at least one of the one or more identified document blocks. The computing system uses the machine learning large language model to process prompts based on the one or more identified document blocks to perform the first task among the plurality of tasks; as well as The computing system obtains the language output generated by the machine learning large language model based on the processing of the prompts.

22. The computer-implemented method of claim 21, wherein before performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, the method comprises: The computing system accesses the multiple block embeddings generated by the machine learning embedding generation model for the multiple document blocks of the multiple documents, wherein the multiple documents are organized into multiple document subsets; as well as The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets.

23. The computer-implemented method of claim 22, wherein obtaining the data indicative of the one or more selected document subsets comprises obtaining data by the computing system indicative of selecting one or more selected document subsets from the plurality of document subsets via interaction between the user and the user interface.

24. The computer-implemented method according to any one of claims 22 to 23, wherein performing the similarity search on the text embedding comprises: The computing system performs a similarity search on the text embedding only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in the one or more selected document subsets as semantically similar to the text query.

25. The computer-implemented method of claim 24, wherein the method further comprises providing the language output by the computing system for display within a user interface associated with a word processing application.

26. The computer-implemented method of claim 25, wherein providing the language output for display within the user interface further includes providing attribution information by the computing system for display within the user interface, wherein the attribution information identifies a document in the one or more selected document subsets that includes an identified document block from the one or more identified document blocks.

27. The computer-implemented method according to any one of claims 21 to 26, wherein the text query includes a second text query received after a previous text query, and wherein the second text query is a response to a previous language output based on the previous text query.

28. The computer-implemented method according to any one of claims 21 to 27, wherein selecting the first task of the plurality of tasks for the machine learning large language model based at least in part on the text query or the at least one of the one or more identified document blocks comprises: The computing system determines a complexity measure that describes the degree of complexity associated with the text query and / or the one or more identified document blocks; The computational system determines that the complexity metric is greater than a threshold complexity. as well as The computing system selects a simplified task from the plurality of tasks for the machine learning large language model based on the determination result.

29. The computer-implemented method according to claim 28, wherein... Processing the prompts based on the one or more identified document blocks using the machine learning large language model to perform the task includes: The computing system uses the machine learning large language model to process the prompts based on the one or more identified document blocks to obtain the language output; as well as The computing system uses the machine learning large language model to generate a simplified language output that describes a simplified representation of the language output.

30. The computer-implemented method of claim 29, wherein the method further comprises: The simplified language output is displayed by the computing system within the user interface, adjacent to the language output.

31. The computer-implemented method according to claim 29, wherein the method further comprises: The simplified language output is displayed by the computing system in a second user interface, which is different from the user interface.

32. The computer-implemented method of claim 29, wherein the method further comprises: The computing system displays the simplified language output within the user interface to replace the original language output.

33. The computer-implemented method according to any one of claims 21 to 27, wherein selecting the first task of the plurality of tasks for the machine learning large language model based at least in part on the text query or the at least one of the one or more identified document blocks comprises: The computing system determines that the text query and / or one or more identified document blocks include text content expressing opinions; as well as The computing system selects opposing viewpoint tasks from among the multiple tasks for the machine learning large language model based on the determined results.

34. The computer-implemented method of claim 33, wherein processing the prompts based on the one or more identified document blocks using the machine learning large language model to perform the task comprises: The computing system processes the cues based on the one or more identified document blocks using the machine learning large language model to obtain the language output, wherein the language output describes an opinion; and The computing system uses the machine learning large language model to generate a second language output describing a second viewpoint that is contrary to the stated viewpoint.

35. The computer-implemented method according to any one of claims 21 to 27, wherein the first task is a thought expansion task, and wherein the one or more identified document blocks comprise a plurality of identified document blocks; and The process of using the machine learning large language model to process the prompts based on the one or more identified document blocks to perform the task includes: For multiple iterations, the computing system processes new prompts to obtain updated language output, wherein the new prompts are based on one or more of the following: (a) a subset of the identified document blocks of the plurality of identified document blocks, or (b) the previously updated language output.

36. A computer system for dynamic task selection in large language models, the computer system comprising: One or more processors; as well as One or more non-transitory computer-readable media, the one or more non-transitory computer-readable media collectively storing instructions, the instructions causing the computer system to perform operations when executed by the one or more processors, the operations including: Obtain user interaction information indicating a text query, the text query comprising at least a portion of a text set generated by the user through interaction with a text editing field of the user interface; The text embedding of the text query is generated using a machine learning embedding generative model; For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, a similarity search is performed on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query; The first task among multiple tasks is selected for the machine learning large language model, based at least in part on the text query or at least one of one or more identified document blocks. The machine learning large language model is used to process prompts based on the one or more identified document blocks to perform the first task of the plurality of tasks; and Obtain the language output generated by the machine learning large language model based on the processing of the prompts.

37. The computer system of claim 36, wherein the operation comprises: performing the similarity search on the text embedding for the plurality of block embeddings generated by the machine learning embedding generation model for the plurality of document blocks of the plurality of documents, respectively: Access the multiple block embeddings generated by the machine learning embedding generation model for the multiple document blocks of the multiple documents, wherein the multiple documents are organized into multiple document subsets; as well as Obtain data indicating one or more selected document subsets from the plurality of document subsets.

38. The computer system of claim 37, wherein obtaining the data indicative of the one or more selected document subsets includes obtaining data indicative of selecting one or more selected document subsets from the plurality of document subsets via interaction between the user and the user interface.

39. The computer system according to any one of claims 37 to 38, wherein performing the similarity search on the text embedding comprises: A similarity search is performed on the text embedding only for block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document blocks included in the one or more selected document subsets as semantically similar to the text query.

40. One or more non-transitory computer-readable media storing instructions that, when executed by one or more processors of a computing system, cause the computing system to perform operations, the operations including: Obtain user interaction information indicating a text query, the text query comprising at least a portion of a text set generated by the user through interaction with a text editing field of the user interface; The text embedding of the text query is generated using a machine learning embedding generative model; For the multiple block embeddings generated by the machine learning embedding generation model for multiple document blocks of multiple documents, a similarity search is performed on the text embeddings, wherein the similarity search identifies one or more of the identified document blocks as semantically similar to the text query; The first task among multiple tasks is selected for the machine learning large language model, based at least in part on the text query or at least one of one or more identified document blocks. The machine learning large language model is used to process prompts based on the one or more identified document blocks to perform the first task among the plurality of tasks; as well as Obtain the language output generated by the machine learning large language model based on the processing of the prompts.

Images