Optimizing user interaction and task selection for large language models

Abstract

Data indicative of a textual query is received. A text embedding of a text query is generated using a machine-learned embedding generation model. A plurality of block inserts respectively generated by an insert generation model for a plurality of document blocks of a plurality of documents are accessed. A plurality of documents are organized into a plurality of document subsets. Data indicative of a selected subset of documents in the plurality of subsets of documents is obtained. A similarity search is performed on text embedding only for block embedding associated with document blocks included in the selected subset of documents. A similarity search identifies the block embedding as semantically similar to the text query. Document blocks corresponding to the block embedding identified by the similarity search are provided for display within the user interface.

Description

TECHNICAL FIELD

[0001] The present disclosure relates generally to optimizing task performance of large language models. More specifically, the present disclosure relates to optimizing interactions between a user and a large language model when selecting a task for the large language model. BACKGROUND

[0002] Large language models are models that have been trained on a vast dataset. This manner of training provides the large language models with the ability to perform a wide variety of types of language tasks. For example, some language models can summarize text, generate counter opinions, facilitate brainstorming, respond to user queries in a conversational manner, etc. In combination, these tasks can facilitate conversational dialog between the model and a user to more efficiently provide relevant information to the user. However, the wide variety of tasks that a large language model can perform makes it difficult to select a particular task at any given time. SUMMARY

[0003] Aspects and advantages of embodiments of the present disclosure will be set forth in part in the following description, or can be learned from the description, or can be learned through practice of the embodiments.

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

[0005] Another example aspect of the present disclosure relates to a computer system for semantic exploration of a specified subset of a plurality of documents. The computer system includes one or more processors and one or more non-transitory computer-readable media. The one or more non-transitory computer-readable media collectively store a plurality of document blocks of a plurality of documents, respectively generated by a machine-learned embedding generation model, wherein the plurality of documents are organized into a plurality of document subsets. The one or more non-transitory computer-readable media collectively store instructions that, when executed by the one or more processors, cause the computer system to perform operations. The operations include receiving data indicative of a text query. The operations include generating, using the machine-learned embedding generation model, a text embedding of the text query. The operations include obtaining data indicative of one or more selected document subsets of the plurality of document subsets. The operations include performing a similarity search of the text embedding only with respect to block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more of the block embeddings as semantically similar to the text query. The operations include providing, for display within a user interface, one or more of the plurality of document blocks corresponding to the one or more of the block embeddings identified by the similarity search.

[0006] Another example aspect of the present disclosure relates to a computer-implemented method for large language model interaction with improved interpretability. The method includes obtaining, by a computing system comprising one or more computing devices, data indicative of a text query. The method includes generating, by the computing system, a text embedding of the text query using a machine-learned embedding generation model. The method includes performing, by the computing system, a similarity search of the text embedding with respect to a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query. The method includes generating, by the computing system, a prompt comprising the one or more identified document blocks. The method includes providing, by the computing system, the prompt as input to and for processing by a machine-learned large language model. The method includes receiving, by the computing system, language output generated by the machine-learned large language model based on the processing of the prompt. The method includes providing, by the computing system, the language output as output.

[0007] Another example aspect of the present disclosure relates to a computer system for large language model interaction with improved interpretability. The computer system includes one or more processors and one or more non-transitory computer-readable media that collectively store instructions that, when executed by the one or more processors, cause the computer system to perform operations. The operations include receiving data indicative of a text query. The operations include generating a text embedding of the text query using a machine-learned embedding generation model. The operations include performing a similarity search of the text embedding against a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query. The operations include generating a prompt that includes the one or more identified document blocks. The operations include providing the prompt as input to and for processing by a machine-learned large language model. The operations include receiving language output generated by the machine-learned large language model based on the processing of the prompt. The operations include providing the language output as output.

[0008] Another example aspect of the present disclosure relates to one or more non-transitory computer-readable media that store instructions that, when executed by one or more processors of a computing system, cause the computing system to perform operations. The operations include receiving data indicative of a text query. The operations include generating a text embedding of the text query using a machine-learned embedding generation model. The operations include performing a similarity search of the text embedding against a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query. The operations include generating a prompt that includes the one or more identified document blocks. The operations include providing the prompt as input to and for processing by a machine-learned large language model. The operations include receiving language output generated by the machine-learned large language model based on the processing of the prompt. The operations include providing the language output as output.

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

[0010] These and other features, aspects, and advantages of various embodiments of the present disclosure will be better understood when considered with reference to the following description and accompanying drawings. The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate example embodiments of the present disclosure and, together with the description, serve to explain the related principles. BRIEF DESCRIPTION OF DRAWINGS

[0011] With reference to the appended drawings, a detailed discussion of embodiments of the application follows in conjunction with the drawings in which:

[0012] FIG. 1A depicts a block diagram of an example computing system for performing optimization of user interaction and task selection for large language models in accordance with example embodiments of the disclosure.

[0013] FIG. 1B depicts a block diagram of an example computing device for performing semantic exploration of a specified subset of multiple documents in accordance with example embodiments of the disclosure.

[0014] FIG. 1C depicts a block diagram of an example computing device for performing facilitation of selection of particular language tasks to enhance user interaction with large language models in accordance with example embodiments of the disclosure.

[0015] FIG. 2 depicts a block diagram of an example machine-learned large language model in accordance with example embodiments of the disclosure.

[0016] FIG. 3 depicts a block diagram of an example machine-learned language model ensemble in accordance with example embodiments of the disclosure.

[0017] FIG. 4 depicts an example user interface for facilitating interaction between a user and a large language model in accordance with some implementations of the disclosure.

[0018] FIG. 5A depicts an example user interface for facilitating interaction between a user and a large language model in accordance with some implementations of the disclosure. FIG. 4 depicts an example user interface for facilitating interaction between a user and a large language model in accordance with some implementations of the disclosure.

[0019] FIG. 5B depicts an example user interface for facilitating interaction between a user and a large language model in accordance with some other implementations of the disclosure. FIG. 4 depicts an example user interface for facilitating interaction between a user and a large language model in accordance with some other implementations of the disclosure.

[0020] FIG. 6A depicts an example user interface for facilitating interaction between a user and a large language model in accordance with some implementations of the disclosure. FIG. 4 depicts an example user interface for facilitating interaction between a user and a large language model in accordance with some implementations of the disclosure.

[0021] FIG. 6B depicts an example user interface for facilitating interaction between a user and a large language model in accordance with some implementations of the disclosure. FIG. 4 depicts an example user interface for facilitating interaction between a user and a large language model in accordance with some implementations of the disclosure.

[0022] FIG. 7AExample user interfaces are depicted for user interaction with a large language model to request the model to perform a summarization task, in accordance with some implementations of the present disclosure.

[0023] FIG. 7B Example user interfaces are depicted for additional user interaction with a large language model to request the model to perform an opposing viewpoints task, in accordance with some implementations of the present disclosure.

[0024] FIG. 7C Example user interfaces are depicted for additional user interaction with a large language model to request the model to perform a brainstorming task, in accordance with some implementations of the present disclosure.

[0025] FIG. 7D Example user interfaces are depicted for additional user interaction with a large language model to request the model to perform a simplification task, in accordance with some implementations of the present disclosure.

[0026] FIG. 8 Various interface layouts in which the interfaces of the previous figures can be implemented are depicted, in accordance with some implementations of the present disclosure.

[0027] FIG. 9 A flowchart of an example method for performing semantic exploration of a specified subset of a plurality of documents, in accordance with example embodiments of the present disclosure, is depicted.

[0028] FIG. 10 A flowchart of an example method for performing large language model interaction with improved interpretability, in accordance with example embodiments of the present disclosure, is depicted.

[0029] FIG. 11 A flowchart of an example method for performing facilitation of selection of particular language tasks to enhance user interaction with a large language model, in accordance with example embodiments of the present disclosure, is depicted.

[0030] FIG. 12 A flowchart of an example method for performing dynamic selection of tasks for a large language model, in accordance with example embodiments of the present disclosure, is depicted.

[0031] Reference numbers repeated across multiple figures are intended to identify the same features in various implementations. DETAILED DESCRIPTION

[0032] SUMMARY

[0033] Generally, the present disclosure relates to optimizing task performance of large language models. More specifically, the present disclosure relates to optimizing interactions between a user and a large language model when selecting a task for the large language model. As an example, a computing system can obtain a textual query from a user. The textual query can be processed with a machine-learned embedding generation model to generate a textual embedding of the query. This query can be used to access a plurality of block embeddings within an embedding space. The block embeddings can each correspond to various blocks of documents, which can be organized in various document subsets. For example, a user can collect ten different types of documents (e.g., articles, patent documents, research papers, websites, etc.) and sort them into document subsets by type (e.g., if four of the ten documents are patent documents, they can be sorted into their own document subset).

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

[0035] In some implementations, the identified document blocks can be provided directly to the user within a user interface. For example, the user can be interacting with a word processing application and the identified document blocks can be provided within the margins of the word document. As another example, the identified document blocks can be provided within some interface and can include provenance information (e.g., citations, etc.) indicating the location of each document block within its respective document.

[0036] Additionally or alternatively, in some implementations, the computing system can utilize the identified document blocks as input to a large language model to provide more information to the user. For example, the computing system can generate a prompt that includes the identified document blocks. The computing system can provide the prompt as input to a machine-learned large language model (e.g., the prompt can be processed with the model, the prompt can be provided to a remote service that implements the model, etc.) to receive language output generated by the model. The language output can be provided to the user.

[0037] In some implementations, the user can specify a particular task for the machine-learned large language model to perform. For example, the user interface can include a variety of selectable task elements corresponding to particular tasks (e.g., a summarization task, an opposing viewpoint task, etc.) that the machine-learned large language model can perform. The computing system can obtain information indicating that the user has selected one of the task elements. The computing system can then use the machine-learned large language model to perform the task corresponding to the task element to obtain a large language output fulfilling the task. For a particular example, the computing system can obtain information indicating that the user has selected a summarization task. The computing system can utilize the machine-learned large language model to process the identified document chunks to obtain a language output. The computing system can then use the machine-learned large language model to generate a summary output summarizing the language output. Alternatively, rather than generating a language output, the computing system can generate an initial language output summarizing the identified document chunks.

[0038] Alternatively, in some implementations, the computing system can automatically determine which task to select for the machine-learned large language model to perform. For example, the computing system can identify the identified document chunks and can determine that the identified document chunks and / or the text query from the user represent a particular viewpoint. Based on the identified document chunks and / or the text query, the computing system can select an opposing viewpoint task. The computing system can then use the machine-learned large language model to generate a language output describing a viewpoint that is opposite to the viewpoint expressed by the identified document chunks and / or the text query. In this way, the computing system can facilitate interactions between the user and the machine-learned large language model to optimize the delivery of information to the user.

[0039] Aspects of the present disclosure provide a number of technical effects and benefits. As one example technical effect and benefit, users of conventional search processes, word processing applications, and the like often must expend significant time and effort to navigate between references, analyze the references, research background information to understand difficult concepts, and the like. However, by optimizing interactions between the user and the machine-learned large language model and facilitating model task selection, implementations of the present disclosure can greatly reduce the time that a user expends to conduct research using a computing device. For example, rather than the user expending hours manually searching through complex academic papers to obtain information, implementations of the present disclosure can optimize interactions between the user and the large language model to provide the same information to the user in a matter of minutes. In turn, this eliminates the expenditure of significant computing resources (e.g., compute cycles, power, memory, etc.) that the user would otherwise use. Additionally, by reducing the time expenditure of the user, implementations of the present disclosure can improve the efficiency of many use cases (e.g., software engineering, medical research, citing documents for research papers, etc.).

[0040] Example embodiments of the present disclosure will now be discussed in further detail with reference to the drawings.

[0041] Example devices and systems

[0042] FIG. 1A A block diagram of an example computing system 100 for performing optimization of user interactions and task selection for large language models in accordance with example embodiments of the present disclosure is depicted. The system 100 includes a user computing device 102, a server computing system 130, and a training computing system 150 communicatively coupled over a network 180.

[0043] The 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), a mobile computing device (e.g., a smartphone or tablet), a gaming console or controller, a wearable computing device, an embedded computing device, or any other type of computing device.

[0044] The user computing device 102 includes one or more processors 112 and a memory 114. The one or more processors 112 can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, a FPGA, a controller, a microcontroller, etc.) and can be one processor or a plurality of processors that are operatively connected. The memory 114 can include one or more non-transitory computer-readable storage media, such as

[0045] In some implementations, the user computing device 102 can store or include one or more models 120. For example, the models 120 can be or can otherwise include various machine-learned models such as neural networks (e.g., deep neural networks), large language models (LLMs), or other types of machine-learned models, including non-linear models and / or linear models. The neural networks can include feed-forward 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-learned models can utilize attention mechanisms such as self-attention. For example, some example machine-learned models can include multi-head self-attention models (e.g., transformer models). See, e.g., Vaswani et al., “Attention is All You Need,” arXiv: 1706.03762v2, 2017. FIG. 2 and FIG. 3 Example models 120 are discussed.

[0046] In some implementations, one or more models 120 can be received from server computing system 130 over 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 can implement multiple parallel instances of a single model 120 (e.g., to perform parallel optimization of user interactions and task selection for large language models across multiple instances of a model 120).

[0047] More specifically, in some implementations, models 120 can include a machine- learned embedding generation model. The machine-learned embedding generation model can be one or more models (e.g., a model architecture including multiple models) of any type or manner sufficient to generate an intermediate representation of a query. In some implementations, the query can be a textual query, and the machine-learned embedding generation model can generate a textual embedding of the textual 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, posture, environment, time, etc.), a multi-modal query (e.g., textual and image input, etc.), etc.), and the machine-learned embedding generation model can generate an intermediate representation (e.g., an embedding) of the query.

[0048] Additionally or alternatively, in some implementations, models 120 can include a machine-learned large language model. The machine-learned large language model can be or otherwise include a model that has been trained on a large corpus of language training data in a manner that provides the machine-learned large language model with the ability to perform a plurality of language tasks. For example, the machine-learned large language model can be trained to perform summarization tasks, conversational tasks, simplification tasks, counterpoint tasks, etc. In particular, the machine-learned large language model can be trained to process a variety of outputs to generate language outputs. For example, the machine-learned large language model can process embeddings generated by the machine-learned embedding generation model, document blocks identified using the embedding generation model, language outputs generated using the machine-learned large language model or some other model, etc.

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

[0050] The user computing device 102 can also include one or more user input components 122 that receive user input. For example, the user input components 122 can be a touch-sensitive component (e.g., a touch-sensitive display screen or a touchpad) that is sensitive to

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

[0052] In some implementations, the server computing system 130 includes or is otherwise implemented by one or more server computing devices. In instances in which the server computing system 130 includes multiple server computing devices, such server computing devices can operate according to a sequential computing architecture, a parallel computing architecture, or some combination thereof.

[0053] As described above, the server computing system 130 can store or otherwise include one or more models 140. For example, the models 140 can be or can otherwise include various machine-learned models. Example machine-learned models include neural networks or other multi-layer non-linear models. Example neural networks include feed-forward neural networks, deep neural networks, recurrent neural networks, and convolutional neural networks. Some example machine-learned models can utilize attention mechanisms, such as self-attention. For example, some example machine-learned models can include multi-head self-attention models (e.g., transformer models). See, e.g., Vaswani et al., “Attention is All You Need,” Advances in Neural Information Processing Systems, 2017. FIG. 2 and FIG. 3 Example models 140 are discussed.

[0054] In particular, the models 140 of the server computing system 130 can include some or all of the models 120 included in the user computing device 102 and can provide such models as a service to the user computing device 102. For example, in some implementations, the models 140 can include a machine-learned embedding generation model. The server computing system 130 can also maintain an embedding space that includes embeddings generated using the machine-learned embedding generation model. The user computing device 102 can provide a query to the server computing system 130, and the server computing system 130 can process the query with the machine-learned embedding generation model to obtain an intermediate representation of the query.

[0055] In some implementations, the server computing system 130 can return the intermediate representation of the query to the user computing device 102. Alternatively, in some implementations, the machine-learned models 140 can include a machine-learned large language model, and the server computing system 130 can process the intermediate representation with the machine-learned large language model to obtain a language output. The language output or information indicative or descriptive of the language output can be provided to the user computing device 102.

[0056] The user computing device 102 and / or the server computing system 130 can train the models 120 and / or 140 via interaction with a training computing system 150 that is communicatively coupled over the network 180. The training computing system 150 can be separate from the server computing system 130 or can be a part of the server computing system 130.

[0057] The training computing system 150 includes one or more processors 152 and a memory 154. The one or more processors 152 can be any suitable processing device (e.g., a processor core, a microprocessor, an ASIC, a FPGA, a controller, a microcontroller, etc.) and can be one processor or a plurality of processors that are operatively connected. The memory 154 can include one or more non-transitory computer-readable storage media, such as

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

[0059] In some implementations, performing error backpropagation can include performing truncated backpropagation through time. The model trainer 160 can perform various generalization techniques (e.g., weight decay, dropout, etc.) to improve the generalization capabilities of the model being trained.

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

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

[0062] The model trainer 160 includes computer logic in the form of programmed procedures, which provide the expected functionality. The model trainer 160 can be implemented in hardware, firmware, and / or software controlling a general purpose processor. For example, in some implementations, the model trainer 160 includes program files stored on a storage device, loaded into memory, and executed by one or more processors. In other implementations, the model trainer 160 includes one or more sets of computer-executable instructions stored in a tangible computer-readable storage medium such as a RAM, a hard disk, or an optical or magnetic medium.

[0063] The network 180 can be any type of communications network, such as a local area network (e.g., an intranet), a wide area network (e.g., the Internet), or some combination thereof, and can include any number of wired or wireless links over any type of medium. In general, communication over the network 180 can be carried out using a wide variety of 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) via any type of wired and / or wireless connection.

[0064] In some implementations, the input to a machine-learned model of the present disclosure can be image data. The machine-learned model can process the image data to generate an output. As an example, the machine-learned model can process the image data to generate an image recognition output (e.g., a recognition of the image data, a latent embedding of the image data, an encoded representation of the image data, a hash of the image data, etc.). As another example, the machine-learned model can process the image data to generate an image segmentation output. As another example, the machine-learned model can process the image data to generate an image classification output. As another example, the machine-learned model can process the image data to generate an image data modification output (e.g., a change to the image data, etc.). As another example, the machine-learned model can process the image data to generate an encoded image data output (e.g., an encoded representation and / or compressed representation of the image data, etc.). As another example, the machine-learned model can process the image data to generate an upscaled image data output. As another example, the machine-learned model can process the image data to generate a prediction output.

[0065] In some implementations, the input to a machine-learned model of the present disclosure can be text or natural language data. The machine-learned model can process the text or natural language data to generate an output. As an example, the machine-learned model can process natural language data to generate a language encoding output. As another example, the machine-learned model can process text or natural language data to generate a latent text embedding output. As another example, the machine-learned model can process text or natural language data to generate a translation output. As another example, the machine-learned model can process text or natural language data to generate a classification output. As another example, the machine-learned model can process text or natural language data to generate a text segmentation output. As another example, the machine-learned model can process text or natural language data to generate a semantic intent output. As another example, the machine-learned model can process text or natural language data to generate a super- resolved 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-learned model can process text or natural language data to generate a prediction output.

[0066] In some implementations, the input to a machine-learned model of the present disclosure can be speech data. The machine-learned model can process the speech data to generate an output. As an example, the machine-learned model can process speech data to generate a speech recognition output. As another example, the machine-learned model can process speech data to generate a speech translation output. As another example, the machine-learned model can process speech data to generate a latent embedding output. As another example, the machine-learned 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-learned model can process speech data to generate a super-resolved speech output (e.g., speech data of higher quality than the input speech data, etc.). As another example, the machine-learned 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-learned model can process speech data to generate a prediction output.

[0067] In some implementations, an input to a machine-learned model of the present disclosure can be latent encoded data (e.g., a latent space representation of an input, etc.). The machine-learned model can process the latent encoded data to generate an output. As an example, the machine-learned model can process the latent encoded data to generate a recognition output. As another example, the machine-learned model can process the latent encoded data to generate a reconstruction output. As another example, the machine-learned model can process the latent encoded data to generate a search output. As another example, the machine-learned model can process the latent encoded data to generate a re-clustering output. As another example, the machine-learned model can process the latent encoded data to generate a prediction output.

[0068] In some implementations, an input to a machine-learned model of the present disclosure can be statistical data. The statistical data can be, represent, or otherwise include data computed and / or calculated from some other data source. The machine-learned model can process the statistical data to generate an output. As an example, the machine-learned model can process the statistical data to generate a recognition output. As another example, the machine-learned model can process the statistical data to generate a prediction output. As another example, the machine-learned model can process the statistical data to generate a classification output. As another example, the machine-learned model can process the statistical data to generate a segmentation output. As another example, the machine-learned model can process the statistical data to generate a visualization output. As another example, the machine-learned model can process the statistical data to generate a diagnosis output.

[0069] In some implementations, an input to a machine-learned model of the present disclosure can be sensor data. The machine-learned model can process the sensor data to generate an output. As an example, the machine-learned model can process the sensor data to generate a recognition output. As another example, the machine-learned model can process the sensor data to generate a prediction output. As another example, the machine-learned model can process the sensor data to generate a classification output. As another example, the machine-learned model can process the sensor data to generate a segmentation output. As another example, the machine-learned model can process the sensor data to generate a visualization output. As another example, the machine-learned model can process the sensor data to generate a diagnosis output. As another example, the machine-learned model can process the sensor data to generate a detection output.

[0070] In some cases, the input includes visual data, and the task is a computer vision task. In some cases, the input includes pixel data for one or more images, and the task is an image processing task. For example, the image processing task can be image classification, in which the output is a set of scores, each score corresponding to a different object class and representing a likelihood that the one or more images depict an object belonging to the object class. The image processing task can be object detection, in which the image processing output identifies one or more regions in the one or more images, and for each region, identifies a likelihood that the region depicts an object of interest. As another example, the image processing task can be image segmentation, in which the image processing output defines, for each pixel in the one or more images, a respective likelihood of each class in a predetermined set of classes. For example, the set of classes can be foreground and background. As another example, the set of classes can be object classes. As another example, the image processing task can be depth estimation, in which the image processing output defines, for each pixel in the one or more images, a respective depth value. As another example, the image processing task can be motion estimation, in which the network input includes multiple images, and the image processing output defines, for each pixel of one of the input images, a motion of a scene depicted at the pixel between the images in the network input.

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

[0072] FIG. 1B A block diagram of an example computing device 10 that performs semantic exploration of a specified subset of multiple documents in accordance with example embodiments of the present disclosure is depicted. The computing device 10 can be a user computing device or a server computing device.

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

[0074] As FIG. 1BAs shown, 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 specific to that application.

[0075] FIG. 1C A block diagram of an example computing device 50 that performs facilitation of selection of particular language tasks to enhance user interactions with large language models in accordance with example embodiments of the present disclosure is depicted. Computing device 50 can be a user computing device or a server computing device.

[0076] Computing device 50 includes multiple applications (e.g., application 1 through 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, and the like. In some implementations, each application can use an API (e.g., a common API across all applications) to communicate with the central intelligence layer (and models stored therein).

[0077] The central intelligence layer includes multiple machine-learned models. For example, as FIG. 1C shown, a respective machine-learned model can be provided for each application and managed by the central intelligence layer. In other implementations, two or more applications can share a single machine-learned model. For example, in some implementations, the central intelligence layer can provide a single model for all applications. In some implementations, the central intelligence layer is included within or otherwise implemented by an operating system of computing device 50.

[0078] The central intelligence layer can communicate with a central device data layer. The central device data layer can be a centralized data store for computing device 50. As FIG. 1C shown, 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 can use an API (e.g., a private API) to communicate with each device component.

[0079] Example model arrangements

[0080] FIG. 2A block diagram of an example machine-learned large language model 200 according to example embodiments of the present disclosure is depicted. In some implementations, the machine-learned model 200 is trained to receive a set of input data 204 that is or otherwise describes identified document chunks, and in response to receiving the input data 204, provide output data 206 that describes language output.

[0081] In some implementations, the input data 204 can also indicate a particular task of a plurality of tasks that the machine-learned large language model 200 can perform. For example, the input data 204 can include an identified document chunk 204A and can indicate a summarization task 204B. The machine-learned large language model 200 can process the input data 204 to generate output data 206 that describes language output summarizing the identified document chunk.

[0082] FIG. 3 A block diagram of an example machine-learned language model integration 300 according to example embodiments of the present disclosure is depicted. The machine-learned language model 300 integration includes a machine-learned embedding generation model 302 and a large language model 306 that is included within the machine-learned language model integration 300 along with FIG. 2 The machine-learned large language model 200 is similar to the machine-learned large language model 200 except that the large language model 306 is included within the machine-learned language model integration 300 along with the machine-learned embedding generation model 302.

[0083] As an example, the input data 304 can include FIG. 2 the specified task 204B and a text query 308. The text query 308 can be a query from a user to the machine-learned language model integration. The machine-learned embedding generation model 302 can process the text query 308 to obtain an intermediate representation 310 of the text query 308. The intermediate representation 310 can be used to perform a search of an embedding space 312 that includes embeddings generated by the machine-learned embedding generation model 302. The embeddings are embeddings of chunks of documents that are organized in a subset of documents 314.

[0084] In particular, the machine-learned embedding generation model 302 can process the intermediate representation 310 to identify a chunk embedding 316 that is semantically similar to the text query 308. The identified document chunk 318 can then be retrieved from a subset of documents 320. The identified document chunk 318 is a chunk of a document of the subset of documents 320 that corresponds to the identified chunk embedding 316.

[0085] The large language model 306 can process the identified document chunks 318 to generate output data 206 describing a language output. In some implementations, the large language model 306 can also be processed or otherwise adjusted based on the specified task 204B. For example, the specified task 204B can be a summarization task. The large language model 306 can be adjusted to perform the summarization task based on the specified task 204B. The large language model 306 can then process the identified document chunks 318 to generate output data 206 that can describe a language output including a summary of the identified document chunks 318.

[0086] Example implementations

[0087] FIG. 4 An example user interface 400 for facilitating interactions between a user and a large language model in accordance with some implementations of the present disclosure is depicted. In particular, the interface 400 can be an interface for a word processing application (e.g., a web application). The interface 400 can include a plurality of documents 402A-402Q (generally referred to as documents 402). Some of the documents 402 can be organized into document subsets 404, 406, 408, and 410. Other documents 402 can be unassigned. To follow the depicted example, the first document subset 404 (e.g., document bottle 1) can be a subset of academic papers, and can include documents (e.g., academic paper documents) 402A, 402B, and 402C. The second document subset 406 can be a subset of patent documents, and can include documents (e.g., patent documents) 402D, 402E, and 402F. The third document subset 408 can be a subset of newspaper articles or clippings documents, and can include documents (e.g., newspaper clippings) 402G, 402H, and 402I. The fourth document subset 410 can be a subset of files (e.g., program instruction files, slide files, word processor files, spreadsheet files, etc.), and can include documents (e.g., files) 402J, 402K, and 402L. The interface 400 can include an unassigned documents section 412 including unassigned documents 402M, 402N, 402O, 402P, and 402Q.

[0088] FIG. 5A An example user interface 400 for facilitating interactions between a user and a large language model in accordance with some implementations of the present disclosure is depicted. In particular, the interface 400 can be an interface for a word processing application (e.g., a web application). The interface 400 can include a plurality of documents 402A-402Q (generally referred to as documents 402). Some of the documents 402 can be organized into document subsets 404, 406, 408, and 410. Other documents 402 can be unassigned. To follow the depicted example, the first document subset 404 (e.g., document bottle 1) can be a subset of academic papers, and can include documents (e.g., academic paper documents) 402A, 402B, and 402C. The second document subset 406 can be a subset of patent documents, and can include documents (e.g., patent documents) 402D, 402E, and 402F. The third document subset 408 can be a subset of newspaper articles or clippings documents, and can include documents (e.g., newspaper clippings) 402G, 402H, and 402I. The fourth document subset 410 can be a subset of files (e.g., program instruction files, slide files, word processor files, spreadsheet files, etc.), and can include documents (e.g., files) 402J, 402K, and 402L. The interface 400 can include an unassigned documents section 412 including unassigned documents 402M, 402N, 402O, 402P, and 402Q. FIG. 4 An example user interface 400 for facilitating interactions between a user and a large language model in accordance with some implementations of the present disclosure is depicted. In particular, the interface 400 can be an interface for a word processing application (e.g., a web application). The interface 400 can include a plurality of documents 402A-402Q (generally referred to as documents 402). Some of the documents 402 can be organized into document subsets 404, 406, 408, and 410. Other documents 402 can be unassigned. To follow the depicted example, the first document subset 404 (e.g., document bottle 1) can be a subset of academic papers, and can include documents (e.g., academic paper documents) 402A, 402B, and 402C. The second document subset 406 can be a subset of patent documents, and can include documents (e.g., patent documents) 402D, 402E, and 402F. The third document subset 408 can be a subset of newspaper articles or clippings documents, and can include documents (e.g., newspaper clippings) 402G, 402H, and 402I. The fourth document subset 410 can be a subset of files (e.g., program instruction files, slide files, word processor files, spreadsheet files, etc.), and can include documents (e.g., files) 402J, 402K, and 402L. The interface 400 can include an unassigned documents section 412 including unassigned documents 402M, 402N, 402O, 402P, and 402Q. FIG. 5AAt this point, 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 to drag document 402M to the document subset 404 associated with the academic paper. The user can manually assign each of documents 402M through 402Q to the document subsets 404 through 410 to which they should be assigned. For example, the user can manually assign document 402N to document subset 408, document 402O to document subset 406, and document 402Q to document subset 410.

[0089] 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. Alternatively, the user can first assign document 402P to the newly created document subset, and the computing system implementing interface 400 can create the association between the newly created document subset and the product information document.

[0090] FIG. 5B Depicting some other implementations of this disclosure and FIG. 4 The example user interface 400 allows for user interaction to assign documents to subsets of documents. Specifically, in FIG. 5B At this point, the user has provided selection input to sorting element 416. Sorting element 416 enables the computing system implementing interface 400 to automatically sort unassigned documents 402M to 402Q into existing document subsets 404 to 410. In some implementations, the computing system can sort unassigned documents 402M to 402Q by determining the document type of each document. 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 newspaper briefing and therefore should be assigned to the document subset 408 associated with newspaper briefings.

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

[0092] More generally, it should be broadly understood that the computing system can assign documents to the document subsets 408 based on any type or manner of criteria (e.g., title, topic, semantic understanding, length, publication date, public accessibility, relevance, file type, etc.). In some implementations, the 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 the document subset 404 and academic paper type documents, and a relatively loose association between the document subset 408 and newspaper clipping type documents. Based on these maintained associations, the computing system can determine to avoid assigning the document 402P to the document subset 404 (e.g., due to the strict association between the subset and academic paper type documents), and instead assign the document 402P to the document subset 408 (e.g., due to the loose association between the subset and newspaper clipping type documents).

[0093] FIG. 6A depicts an example user interface 400 in accordance with some implementations of the present disclosure in user interaction with FIG. 4 to select a document subset from among the plurality of document subsets. Specifically, in some implementations, the user can provide a cursor input 602 that selects the document subset 404. Alternatively, in some implementations, the user can provide a query 604 within the query field 606. The query field 606 can allow the user to provide a query to the computer system via the interface 400. Specifically, as depicted, the user can provide a query 604 to the computing system within the query field 606 that asks "how much genetic drift has occurred in cats?" and instructs the computing system to determine this information based on the documents assigned to the document subset 404.

[0094] FIG. 6Bdepicts an example user interface 400 for user interaction with a FIG. 4 machine-learned large language model 200, etc.) via a query field. Specifically, the query field 604 can be used to facilitate user interaction with a large language model (e.g., the machine-learned large language model 200, etc.) of FIG. 2 the depicted example, the user can provide a query regarding FIG. 6A described. The computing system can process the query 604 to obtain an output 608. In some implementations, the computing system can process the query 604 with a machine-learned embedding model (e.g., as described with respect to FIG. 3 to identify document blocks that are semantically similar to the query 604 and can return the blocks as the output 608. Alternatively, in some implementations, the computing system can process the identified document blocks with a machine-learned large language model (e.g., as described with respect to FIG. 3 to obtain an output 608 that includes language output.

[0095] The computing system can provide the output 608 for display within the query field 606 of the interface 400. The user can provide a second query 610 within the 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 the query field 606. Additionally, in some implementations, the computing system can provide attribution information 614 for display within the interface 400. The attribution information 614 can identify the document on which the language output 612 is based. In some implementations, if the output 612 includes a particular document block from the document 402, the attribution information 614 can describe the specific location of the identified document block within the document 402 from which it originated. For example, the attribution information 614 can be or otherwise describe a citation in a particular citation format (e.g., MLA, Chicago style, Bluebook, etc.) that presents the location of the identified document block. As another example, the attribution information 614 can include a link that, when selected by the user, navigates the user to the location within the document from which the document block originated.

[0096] FIG. 7A depicts an example user interface 700 for user interaction with a large language model to request the model to perform a summarization task, according to some implementations of the present disclosure. Specifically, FIG. 7A the interface of the depicted example can present, in response to user selection of a selectable link included in the attribution information 614, as described with respect to FIG. 6BThe interface 700 displays the document 402M from the subset of documents 404 in response to user selection of the selectable link as described. Once the 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 performance of a summarization task. Specifically, the query 702 includes a textual query from the user (e.g., “summarize this”) as well as an identified (i.e., highlighted) document chunk 704. The computing system can process the query 702 with the machine-learned embedding model to obtain an embedding of the query, and can process the embedding of the query with the machine-learned large language model to obtain a language output 706. The language output 706 can summarize the identified document chunk 704.

[0097] The user can provide an additional query 708 instructing the computing system to navigate to a different document. The computing system can process the query 708 to determine instructions for navigating to the different document. For example, the computing system can process the query 708 with the machine-learned large language model to determine the instructions.

[0098] FIG. 7B An example user interface 700 is depicted for use in requesting a model to perform an opposing viewpoint task using a large language model in accordance with some implementations of the present disclosure. Specifically, FIG. 7B The interface 700 can include a document 402H in response to FIG. 7A the query 708 described in the section entitled “Summarization Task”. In some implementations, in addition to displaying the document 402H, the computing system can also provide a plurality of task elements 710 each corresponding to a particular task that is executable by the machine-learned large language model. For example, task element 710A corresponds to performance of a summarization task as described in the section entitled “Summarization Task”. Task element 710B corresponds to performance of a simplification task. Task element 710C corresponds to performance of an opposing viewpoint task (i.e., an “opposite” opinion). Finally, task element 710D corresponds to a brainstorming task. FIG. 7A

[0099] ​The user can select task element 710C. In response, the computing system can execute an opposing viewpoint task using the machine-learned large language model to generate language output 712. Language output 712 can describe an opinion that is contrary to an opinion expressed by document 402H (or a relevant identified document chunk of document 402H). To follow the depicted example, the user can select opposing viewpoint element 706C and select (e.g., highlight, etc.) a document chunk from document 402H. The computing system can process the document chunk to execute the opposing viewpoint task to generate language output 712 that describes an opinion that is contrary to an opinion expressed in the document chunk. In some implementations, the computing system can make a determination that the text content expresses an opinion, and based on the determination, the opposing viewpoint task can be selected for the machine-learned large language model.

[0100] FIG. 7C An additional user interaction with the large language model using example user interface 700 to request the model to execute a summarization task is depicted in accordance with some implementations of the present disclosure. Specifically, as depicted in FIG. 7C In some implementations, the computing system can ask which document subset to utilize to execute the summarization task. For example, the user can specify that they want the summarization to be executed based on document subset 2 (e.g., document subset 406 associated with patent documents). In response, the computing system can generate a plurality of language outputs 714 and display the language outputs 714 to the user within interface 700. Language outputs 714 can each be iteratively generated based on different identified documents, document chunks, combinations of identified document chunks, etc.

[0101] FIG. 7D An additional user interaction with the large language model using example user interface 700 to request the model to execute a simplification task is depicted in accordance with some implementations of the present disclosure. Specifically, in some implementations, rather than selecting a task element, the computing system can automatically determine to use the machine-learned large language model to execute a particular task. For example, the computing system can determine a complexity measure (e.g., a term frequency-inverse document frequency (TF-IDF) measure, a measure generated using a complexity classification model, etc.) that describes a degree of complexity associated with an identified chunk of document 402C. Based on making a determination that the complexity measure is greater than a threshold degree of complexity, the computing system can select a simplification task of a plurality of tasks for the machine-learned large language model. The computing system can utilize the machine-learned large language model to process the identified document chunk from document 402C to generate language output 716 that is a simplified language output that simplifies the identified document chunk. In some implementations, the computing system can replace the language output with the simplified language output within the user interface.

[0102] FIG. 8 Various interface layouts in which the interfaces of the previous figures can be implemented are depicted in accordance with some implementations of the present disclosure. More generally, it should be broadly appreciated that the described interfaces are merely shown to demonstrate ways in which user interaction with large language models can be facilitated. However, such interfaces can be implemented using any type or manner of layout, design, interface elements, application, etc. FIG. 4 to FIG. 7D

[0103] As a particular example, FIG. 8 An interface of a web application is shown in which a user can enter data in a text editing interface 802. For example, the text editing interface 802 can be an interface of a word processing application that allows a user to enter textual content into the word processing application. As another example, the text editing interface 802 can be an interface that allows a user to enter text into a spreadsheet application, a slideshow application, a calendar application, an instant messaging application, a database application, a social media application, a gaming application, etc.

[0104] In some implementations, FIG. 4 to FIG. 7D The interface of FIG. 1 can be located within some or all of the interface locations 804, 806, 808, 810, and 812. For example, FIG. 4 to FIG. 6B The interface 400 of FIG. 4 can be located within the interface location 806 (e.g., to allow a user to manipulate the subset of documents by adding, removing, reordering the documents, etc.). FIG. 7A to FIG. 7D The interface 700 of FIG. 7 can be implemented in any of the interface locations 804, 808, 810, and 812, or can be distributed across multiple interface locations.

[0105] As a particular example, FIG. 6A The query field 606 of FIG. 6 can be implemented in the interface location 810. Language output from the machine-learned large language model can be presented and stored / indexed in the interface location 808. Identified document chunks can be retrieved from the documents managed at the interface location 806 and displayed to the user within the interface location 804. Additional settings for each of these interface implementations can be modified within a separate interface (e.g., a separate tab from the current interface) accessible from the interface location 814.

[0106] Accordingly, it should be broadly appreciated that implementations of the present disclosure are not limited to the particular interface implementations shown herein. Rather, the implementations described herein that facilitate semantic exploration of a specified subset of documents, large language model interaction with improved interpretability, selection of particular language tasks to enhance user interaction with a large language model, and / or dynamic selection of tasks for a large language model can be implemented using any type or manner of user interface.

[0107] ​Example methods

[0108] FIG. 9 A flowchart of an example method 900 for performing semantic exploration of a specified subset of a plurality of documents in accordance with example embodiments of the present disclosure is depicted. Although the method 900 is depicted as a sequence of steps, it will be appreciated that the method 900 is not limited by the illustrated order of steps. Various steps of the method 900 can be omitted, rearranged, combined, and / or adjusted without departing from the scope of the present disclosure. FIG. 9 For purposes of illustration and discussion, the steps are depicted as being performed in a particular order, but the methods of the present disclosure are not limited to the particularly illustrated order or arrangement. Various steps of the method 900 can be omitted, rearranged, combined, and / or adjusted in various ways without departing from the scope of the present disclosure.

[0109] At 902, a computing system comprising one or more computing devices can receive data indicative of a text query.

[0110] At 904, the computing system can generate a text embedding for the text query using a machine-learned embedding generation model.

[0111] At 906, the computing system can access a plurality of block embeddings respectively generated by the machine-learned embedding generation model for a plurality of document blocks of a plurality of documents. The plurality of documents can be organized into a plurality of document subsets.

[0112] At 908, the computing system can obtain data indicative of one or more selected document subsets of the plurality of document subsets. In some implementations, the one or more selected document subsets are specified by a user. In some implementations, at least some of the documents included in the one or more selected document subsets comprise documents supplied by the user. In some implementations, at least some of the documents included in the one or more selected document subsets comprise 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.).

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

[0114] At 912, the computing system can provide one or more of the plurality of document chunks that correspond to one or more of the chunks embeddings identified by the 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 a user of the user interface to generate a set of text, and the text query includes at least a portion of the set of text generated by the user through interaction with the main text editing field. In some implementations, the user interface includes a main text editing field that enables a user to generate a set of text; and a query field separate from the main text editing field, the query field enabling the user to input a text query separate from the set of text.

[0115] In some implementations, the user interface includes a document subset selection tool that enables a user to provide user input to select one or more selected document subsets from the 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 enables a user to apply a set of filtering logic to the plurality of document subsets, where application of the filtering logic selects the one or more selected document subsets from the plurality of document subsets.

[0116] In some implementations, the computing system obtains a plurality of documents, parses the plurality of documents into a plurality of document chunks, and generates a plurality of chunk embeddings using the machine-learned embedding generation model.

[0117] FIG. 10 A flow diagram depicting an example method 1000 for performing large language model interactions with improved interpretability in accordance with example embodiments of the present disclosure is depicted. Although the method 1000 is depicted as a sequence of steps, it is understood that the method 1000 can be performed in a different order, or in parallel, without departing from the scope of the present disclosure. FIG. 10 The steps depicted for purposes of illustration and discussion are performed in a particular order, but the methods of the present disclosure are not limited to the particular order or arrangement shown. Individual steps of the method 1000 can be omitted, rearranged, combined, and / or adjusted in various ways without departing from the scope of the present disclosure.

[0118] At 1002-1004, the computing system can receive data indicative of a text query and generate a text embedding for the text query using a machine-learned embedding generation model, as described with respect to FIG. 9 .

[0119] At 1006, the computing system can perform a similarity search of the text embedding against a plurality of chunk embeddings respectively generated by the machine-learned embedding generation model for a plurality of document chunks of a plurality of documents. The similarity search identifies one or more identified document chunks of the plurality of document chunks as semantically similar to the text query.

[0120] In some implementations, prior to performing the similarity search on the text embedding against the plurality of document embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents, the computing system can access the plurality of document embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents. The plurality of documents are organized into a plurality of document subsets. In some implementations, the computing system can obtain data indicative of one or more selected document subsets of the plurality of document subsets.

[0121] In some implementations, performing the similarity search on the text embedding can include performing the similarity search on the text embedding against only the document block embeddings associated with the document blocks included in the one or more selected document subsets. The similarity search identifies one or more identified document blocks of the plurality of document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0122] At 1008, the computing system generates a prompt including the one or more identified document blocks.

[0123] At 1010, the computing system provides the prompt as input to and for processing by the machine-learned large language model.

[0124] At 1012, the computing system receives language output generated by the machine-learned large language model based on processing of the prompt.

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

[0126] In some implementations, the computing system can receive data indicative of a second text query including at least a portion of a second set of text generated by the user through interaction with the main text edit field. The second set of text is responsive to the language output.

[0127] In some implementations, the computing system can also generate a second text embedding for the second text query using the machine-learned embedding generation model. The computing system can perform a second similarity search of the second text embedding against only the block embeddings associated with the document blocks included in the one or more second document subsets of the plurality of document subsets. The second similarity search identifies one or more second identified document blocks of the document blocks included in the one or more second document subsets as semantically similar to the second text query. The computing system can generate a second prompt that includes the one or more second identified document blocks. The computing system can provide the second prompt as input to and for processing by the machine-learned large language model. The computing system can receive a second language output generated by the machine-learned large language model based on the processing of the second prompt. The computing system can provide the second language output for display within the user interface associated with the word processing application.

[0128] In some implementations, prior to performing the second similarity search of the second text embedding against only the block embeddings associated with the document blocks included in the one or more second document subsets, the computing system can obtain information indicating a selection of the one or more second document subsets from the plurality of document subsets by the user. In some implementations, 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. 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 enables the user to apply a set of filtering logic to the plurality of document subsets. Application of the filtering logic selects the one or more selected document subsets from the plurality of document subsets.

[0129] In some implementations, prior to performing the second similarity search of the second text embedding against only the block embeddings associated with the document blocks included in the one or more second document subsets, the computing system can select the one or more second document subsets from the plurality of document subsets based at least in part on a second set of text generated by the user.

[0130] FIG. 11 A flow diagram depicting an example method 1100 for performing facilitation of selection of particular language tasks to enhance user interaction with a large language model in accordance with example embodiments of the present disclosure is depicted. Although the method 1100 is depicted as a series of acts, it is contemplated that the method 1100 can be implemented as software, firmware, hardware, or a combination thereof. FIG. 11 The steps depicted for purposes of illustration and discussion are performed in a particular order, but the methods of the present disclosure are not limited to the particular order or arrangement shown. Individual steps of the method 1100 can be omitted, rearranged, combined, and / or adjusted in various ways without departing from the scope of the present disclosure.

[0131] At 1102, the computing system can obtain user interaction information. The user interaction information can be indicative of (a) a text query comprising at least a portion of a set of text generated by a user through interaction with a text edit field of a user interface, where the user interface includes the text edit field and a plurality of selectable task elements respectively associated with a plurality of tasks of a machine-learned large language model; and (b) a selected task element selected by the user from the plurality of selectable task elements.

[0132] At 1104, the computing system can generate a text embedding for the text query using a machine-learned embedding generation model.

[0133] At 1106, the computing system performs a similarity search of the text embedding against a plurality of block embeddings respectively generated by the machine-learned embedding generation model for a plurality of document blocks of a plurality of documents. The similarity search identifies one or more identified document blocks of the plurality of document blocks as semantically similar to the text query.

[0134] In some implementations, prior to performing the similarity search of the text embedding against the plurality of block embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents, the computing system can access the plurality of block embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents, where the plurality of documents are organized into a plurality of document subsets. The computing system can obtain data indicative of one or more selected document subsets of the plurality of document subsets. In some implementations, obtaining the data indicative of the one or more selected document subsets can include obtaining data indicative of selection of the one or more selected document subsets of the plurality of document subsets by the user via interaction with the user interface.

[0135] In some implementations, performing the similarity search of the text embedding can include performing the similarity search of the text embedding only against block embeddings associated with document blocks included in the one or more selected document subsets, where the similarity search identifies one or more identified document blocks of the plurality of document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0136] At 1108, the computing system can utilize the machine-learned large language model to process the prompt based on the one or more identified document blocks to perform the task of the plurality of tasks associated with the selected task element.

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

[0138] In some implementations, the computing system can provide the language output for display within a user interface associated with the word processing application. In some implementations, providing the language output for display within the user interface can further include providing provenance information for display within the user interface, where the provenance information identifies documents of the one or more document subsets that include an identified document chunk of the one or more identified document chunks.

[0139] In some implementations, the text query can include a second text query received after a previous text query, and where the second text query is responsive to a previous language output based on the previous text query.

[0140] In some implementations, the selected task element is associated with an idea expansion task of the plurality of tasks, and where the one or more identified document chunks include a plurality of identified document chunks. Processing the prompt based on the one or more identified document chunks to perform the task with the machine-learned large language model can include, for a number of iterations, processing, by the computing system, a new prompt to obtain an updated language output, where the new prompt is based on one or more of: (a) a subset of the identified document chunks of the plurality of identified document chunks or (b) a previous updated language output.

[0141] In some implementations, the selected task element is associated with a summarization task of the plurality of tasks. Processing the prompt based on the one or more identified document chunks to perform the task with the machine-learned large language model can include processing the prompt based on the one or more identified document chunks to obtain a language output with the machine-learned large language model, where the language output includes a summary of the one or more identified document chunks.

[0142] In some implementations, the selected task element is associated with a simplification task of the plurality of tasks. Processing the prompt based on the one or more identified document chunks to perform the task with the machine-learned large language model can include processing the prompt based on the one or more identified document chunks to obtain a language output with the machine-learned large language model. The computing system can use the machine-learned large language model to generate a simplified language output that describes a simplified representation of the language output.

[0143] In some implementations, the selected task element is associated with an opposing viewpoint task of the plurality of tasks. Processing the prompt based on the one or more identified document chunks to perform the task with the machine-learned large language model can include processing the prompt based on the one or more identified document chunks to obtain a language output with the machine-learned large language model. The language output describes a viewpoint. The computing system can use the machine-learned large language model to generate a second language output that describes a second viewpoint that is opposite the viewpoint.

[0144] FIG. 12 A flow diagram of an example method 1200 for performing dynamic selection of tasks for large language models according to example embodiments of the present disclosure is depicted in accordance with example embodiments of the present disclosure. Although the method 1200 is described as performing the steps depicted in a particular order, the method of the present disclosure is not limited to the order or arrangement specifically shown. Individual steps of the method 1200 can be omitted, rearranged, combined, and / or adjusted in various ways without departing from the scope of the present disclosure. FIG. 12 The steps depicted for purposes of illustration and discussion are performed in a particular order, but the method of the present disclosure is not limited to the order or arrangement specifically shown. Individual steps of the method 1200 can be omitted, rearranged, combined, and / or adjusted in various ways without departing from the scope of the present disclosure.

[0145] At 1202, the computing system can obtain user interaction information indicative of a text query, the text query including at least a portion of a set of text generated by a user through interaction with a text edit field of a user interface.

[0146] At 1204, the computing system can generate a text embedding for the text query using a machine-learned embedding generation model.

[0147] At 1206, the computing system can perform a similarity search of the text embedding against a plurality of block embeddings respectively generated by the machine-learned embedding generation model for a plurality of document blocks of a plurality of documents. The similarity search identifies one or more identified document blocks of the plurality of document blocks as semantically similar to the text query.

[0148] At 1208, the computing system can select, based at least in part on the text query or at least one of the one or more identified document blocks, a first task of a plurality of tasks for the machine-learned large language model.

[0149] At 1210, the computing system can process, with the machine-learned large language model, a prompt based on the one or more identified document blocks to perform the first task of the plurality of tasks associated with the selected task element.

[0150] At 1212, the computing system can obtain language output generated by the machine-learned large language model based on the processing of the prompt.

[0151] ADDITIONAL DISCLOSURE

[0152] The technology discussed herein makes reference to servers, databases, software applications, and other computer-based systems and actions taken by and information sent to and from such systems. The inherent flexibility of computer-based systems allows for a great variety of possible configurations, combinations, and divisions of tasks and

[0153] While the subject matter has been described in detail with respect to various specific embodiments of the subject matter, it should be understood that the various embodiments are given by way of illustration only and for purposes of explanation. It is contemplated that persons having ordinary skill in the art to which the subject matter relates will be able to alter, modify and / or adapt the various embodiments to suit their particular requirements and / or circumstances. Accordingly, the present disclosure is intended to encompass all such alterations, modifications and / or additions of the various embodiments as fall within the scope of the present disclosure. For example, features shown or described as part of one embodiment can be used with another embodiment to yield still a further embodiment. Thus, it is intended that the present disclosure encompass such alterations, modifications and / or additions of the various embodiments as fall within the scope of the present disclosure.

[0154] Implementation

[0155] The following implementations include some of the many implementations described herein. While the processes in the figures can illustrate a particular order of executing an operation, it should be understood that this order is exemplary (e.g., alternative implementations can execute the operations in a different order, combine certain operations, overlap certain operations, etc.).

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

[0157] receiving, by a computing system comprising one or more computing devices, data indicative of a text query;

[0158] generating, by the computing system, a text embedding of the text query using a machine-learned embedding generation model;

[0159] accessing, by the computing system, a plurality of block embeddings respectively generated by the machine-learned embedding generation model for a plurality of document blocks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets;

[0160] obtaining, by the computing system, data indicative of one or more selected document subsets of the plurality of document subsets;

[0161] performing, by the computing system, 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 of the block embeddings as semantically similar to the text query; and

[0162] providing, by the computing system, for display within a user interface, one or more of the plurality of document blocks corresponding to the one or more of the block embeddings identified by the similarity search.

[0163] Implementation 2: The computer-implemented method of implementation 1, wherein the user interface comprises a text editing interface associated with a word processing application.

[0164] Implementation 3: The computer-implemented method of implementation 2, wherein:

[0165] the user interface comprises a main text editing field that enables a user of the user interface to generate a set of text; and

[0166] the text query comprises at least a portion of the set of text generated by the user through interaction with the main text editing field.

[0167] Implementation 4: The computer-implemented method of implementation 2, wherein the user interface comprises:

[0168] a main text editing field that enables the user to generate a set of text; and

[0169] a query field separate from the main text editing field that enables the user to input the text query separate from the set of text.

[0170] Implementation 5: The computer-implemented method of any preceding implementation, wherein the one or more selected document subsets are specified by the user.

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

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

[0173] Implementation 8: The computer-implemented method of 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 application of the filtering logic selects the one or more selected document subsets from the plurality of document subsets.

[0174] Implementation 9: The computer-implemented method of any preceding implementation, wherein at least some of the documents included in the one or more selected subsets of documents comprise documents supplied by the user.

[0175] Implementation 10: The computer-implemented method of any preceding implementation, wherein at least some of the documents included in the one or more selected subsets of documents comprise:

[0176] a book;

[0177] a product manual;

[0178] a legal opinion;

[0179] an academic paper;

[0180] a proprietary data file; or

[0181] a patent document.

[0182] Implementation 11: The computer-implemented method of any preceding implementation, further comprising:

[0183] obtaining, by the computing system, the plurality of documents;

[0184] parsing, by the computing system, the plurality of documents into the plurality of document blocks; and

[0185] generating, by the computing system, the plurality of block embeddings using the machine-learned embedding generation model.

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

[0187] one or more processors; and

[0188] one or more non-transitory computer-readable media collectively storing:

[0189] a plurality of block embeddings respectively generated by a machine-learned embedding generation model for a plurality of document blocks of the plurality of documents, wherein the plurality of documents are organized into a plurality of subsets of documents; and

[0190] instructions that, when executed by the one or more processors, cause the computer system to perform operations comprising:

[0191] receiving data indicative of a text query;

[0192] generating, using the machine-learned embedding generation model, a text embedding for the text query;

[0193] obtaining data indicative of one or more selected document subsets of the plurality of document subsets;

[0194] performing a similarity search on the text embedding only with respect to block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more of the block embeddings as semantically similar to the text query; and

[0195] providing, for display within a user interface, one or more of the plurality of document blocks corresponding to the one or more of the block embeddings identified by the similarity search.

[0196] Implementation 13: The computer system of implementation 12, wherein the user interface comprises a text editing interface associated with a word processing application.

[0197] Implementation 14: The computer system of implementation 13, wherein:

[0198] the user interface comprises a primary text editing field that enables the user to generate a set of text; and

[0199] the text query comprises at least a portion of the set of text generated by the user through interaction with the primary text editing field.

[0200] Implementation 15: The computer system of implementation 13, wherein the user interface comprises:

[0201] a primary text editing field that enables the user to generate a set of text; and

[0202] a query field separate from the main text edit field, the query field enabling the user to input the text query separate from the set of text.

[0203] Implementation 16: The computer system of any of implementations 12-15, wherein the one or more selected document subsets are specified by the user.

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

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

[0206] Implementation 19: The computer system of 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 application of the filtering logic selects the one or more selected document subsets from the plurality of document subsets.

[0207] Implementation 20: The computer system of any of implementations 12-19, wherein the operations further comprise:

[0208] obtaining the plurality of documents;

[0209] parsing the plurality of documents into the plurality of document chunks; and

[0210] generating the plurality of chunk embeddings using the machine-learned embedding generation model.

[0211] Implementation 21: A computer-implemented method for large language model interaction with improved interpretability, the method comprising:

[0212] receiving, by a computing system comprising one or more computing devices, data indicative of a text query;

[0213] generating, by the computing system using a machine-learned embedding generation model, a text embedding of the text query;

[0214] performing, by the computing system, a similarity search on the text embedding for a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query;

[0215] generating, by the computing system, a prompt including the one or more identified document blocks;

[0216] providing, by the computing system, the prompt as input to and for processing by a machine-learned large language model;

[0217] receiving, by the computing system, language output generated by the machine-learned large language model based on the processing of the prompt; and

[0218] providing, by the computing system, the language output as output.

[0219] Implementation 22: The computer-implemented method of implementation 21, wherein prior to performing the similarity search on the text embedding for the plurality of block embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents, the method comprises accessing, by the computing system, the plurality of block embeddings respectively generated by the machine-learned 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 subsets of documents.

[0220] Implementation 23: The computer-implemented method of implementation 22, wherein accessing the plurality of block embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents further comprises obtaining, by the computing system, data indicating one or more selected subsets of documents of the plurality of subsets of documents.

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

[0222] Implementation 25: The computer-implemented method of implementation 24, wherein providing the linguistic output as output comprises providing, by the computing system, the linguistic output for display within a user interface associated with a word processing application.

[0223] Implementation 26: The computer-implemented method of implementation 25, wherein providing the linguistic output for display within the user interface further comprises providing, by the computing system, provenance information for display within the user interface, wherein the provenance information identifies documents of the one or more selected subsets of documents that include an identified document chunk of the one or more identified document chunks.

[0224] Implementation 27: The computer-implemented method of implementation 26, wherein the provenance information describes a location of the identified document chunk within the document.

[0225] Implementation 28: The computer-implemented method of implementation 25, wherein the user interface comprises a main text edit field that enables a user of the user interface to generate a set of text; and the text query comprises at least a portion of the set of text generated by the user through interaction with the main text edit field.

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

[0227] Implementation 30: The computer-implemented method of any one of implementations 28-29, wherein the method further comprises receiving, by the computing system, data indicative of a second text query comprising at least a portion of a second set of text generated by the user through interaction with the main text edit field, wherein the second set of text is responsive to the linguistic output.

[0228] Implementation 31 : The computer-implemented method of implementation 30, wherein the method further comprises:

[0229] generating, by the computing system, a second text embedding for the second text query using the machine-learned embedding generation model;

[0230] performing, by the computing system, a second similarity search of the second text embedding against only the block embeddings associated with the document blocks 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 of the document blocks included in the one or more second document subsets as semantically similar to the second text query;

[0231] generating, by the computing system, a second prompt including the one or more second identified document blocks;

[0232] providing, by the computing system, the second prompt as input to and for processing by the machine-learned large language model;

[0233] receiving, by the computing system, a second language output generated by the machine-learned large language model based on the processing of the second prompt; and

[0234] providing, by the computing system, the second language output for display within the user interface associated with the word processing application.

[0235] Implementation 32: The computer-implemented method of implementation 31, wherein prior to performing the second similarity search of the second text embedding against only the block embeddings associated with the document blocks included in the one or more second document subsets, the method includes obtaining, by the computing system, information indicating a selection of the one or more second document subsets from the plurality of document subsets by the user.

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

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

[0238] Implementation 35: The computer-implemented method of 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 application of the filtering logic selects the one or more selected document subsets from the plurality of document subsets.

[0239] Implementation 36: The computer-implemented method of implementation 31, wherein, prior to performing the second similarity search on the second text embedding only for the block embeddings associated with the document blocks included in the one or more second document subsets, the method comprises selecting, by the computing system, the one or more second document subsets from among the plurality of document subsets based at least in part on the second set of text generated by the user.

[0240] Implementation 37: A computer system for large language model interaction with improved interpretability, the computer system comprising:

[0241] one or more processors; and

[0242] one or more non-transitory computer-readable media collectively storing instructions that, when executed by the one or more processors, cause the computer system to perform operations comprising:

[0243] receiving data indicative of a text query;

[0244] generating, using a machine-learned embedding generation model, a text embedding for the text query;

[0245] performing a similarity search on the text embedding for a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query;

[0246] generating a prompt comprising the one or more identified document blocks;

[0247] providing the prompt as input to and for processing by a machine-learned large language model;

[0248] receiving language output generated by the machine-learned large language model based on the processing of the prompt; and

[0249] providing the language output as output.

[0250] Implementation 38: The computer system of implementation 37, wherein prior to performing the similarity search of the text embedding against the plurality of chunk embeddings respectively generated by the machine-learned embedding generation model for the plurality of document chunks of the plurality of documents, the operations comprise accessing the plurality of chunk embeddings respectively generated by the machine-learned embedding generation model for the plurality of document chunks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets.

[0251] Implementation 39: The computer system of implementation 38, wherein accessing the plurality of chunk embeddings respectively generated by the machine-learned embedding generation model for the plurality of document chunks of the plurality of documents further comprises obtaining data indicative of one or more selected document subsets of the plurality of document subsets.

[0252] 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 comprising:

[0253] receiving data indicative of a text query;

[0254] generating, using a machine-learned embedding generation model, a text embedding for the text query;

[0255] performing a similarity search of the text embedding against a plurality of chunk embeddings respectively generated by the machine-learned embedding generation model for a plurality of document chunks of a plurality of documents, wherein the similarity search identifies one or more identified document chunks of the plurality of document chunks as semantically similar to the text query;

[0256] generating a prompt comprising the one or more identified document chunks;

[0257] providing the prompt as input to and for processing by a machine-learned large language model;

[0258] receiving language output generated by the machine-learned large language model based on the processing of the prompt; and

[0259] providing the language output as output.

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

[0261] obtaining, by a computing system comprising one or more computing devices, user interaction information indicative of:

[0262] a text query comprising at least a portion of a set of text generated by a user through interaction with a text edit field of a user interface, wherein the user interface comprises the text edit field and a plurality of selectable task elements respectively associated with a plurality of tasks of a machine-learned large language model; and

[0263] a selected task element selected by the user from the plurality of selectable task elements;

[0264] generating, by the computing system, a text embedding of the text query using a machine-learned embedding generation model;

[0265] performing, by the computing system, a similarity search of the text embedding against a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query;

[0266] processing, by the computing system, a prompt based on the one or more identified document blocks with the machine-learned large language model to perform a task of the plurality of tasks associated with the selected task element; and

[0267] obtaining, by the computing system, language output generated by the machine-learned large language model based on the processing of the prompt.

[0268] Implementation 42: The computer-implemented method of implementation 41, wherein prior to performing the similarity search of the text embedding against the plurality of block embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents, the method comprises accessing, by the computing system, the plurality of block embeddings respectively generated by the machine-learned 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 obtaining, by the computing system, data indicative of one or more selected document subsets of the plurality of document subsets.

[0269] Implementation 43: The computer-implemented method of implementation 42, wherein obtaining the data indicative of the one or more selected document subsets comprises obtaining, by the computing system, data indicative of a selection of one or more selected document subsets of the plurality of document subsets by the user via interaction with the user interface.

[0270] Implementation 44: The computer-implemented method of any of implementations 42-43, wherein performing the similarity search on the text embedding comprises performing, by the computing system, a similarity search on the text embedding only for chunk embeddings associated with document chunks included in the one or more selected document subsets, wherein the similarity search identifies one or more identified document chunks of the plurality of document chunks included in the one or more selected document subsets as semantically similar to the text query.

[0271] Implementation 45: The computer-implemented method of implementation 44, wherein the method further comprises providing, by the computing system, the linguistic output for display within a user interface associated with a word processing application.

[0272] Implementation 46: The computer-implemented method of implementation 45, wherein providing the linguistic output for display within the user interface further comprises providing, by the computing system, provenance information for display within the user interface, wherein the provenance information identifies documents of the one or more selected document subsets that include an identified document chunk of the one or more identified document chunks.

[0273] Implementation 47: The computer-implemented method of any of implementations 41-46, wherein the text query comprises a second text query received after a prior text query, and wherein the second text query is responsive to prior linguistic output based on the prior text query.

[0274] Implementation 48: The computer-implemented method of any of implementations 41-47, wherein the selected task element is associated with an idea expansion task of the plurality of tasks, and wherein the one or more identified document chunks comprise a plurality of identified document chunks; and wherein processing, with the machine-learned large language model, the prompt based on the one or more identified document chunks to perform the task comprises, for a number of iterations, processing, by the computing system, a new prompt to obtain updated linguistic output, wherein the new prompt is based on one or more of: (a) a subset of identified document chunks of the plurality of identified document chunks or (b) prior updated linguistic output.

[0275] Implementation 49: The computer-implemented method of any of implementations 41-47, wherein the selected task element is associated with a summarization task of the plurality of tasks; and wherein processing the prompt to perform the task based on the one or more identified document blocks utilizing the machine-learned large language model comprises processing, by the computing system, the prompt based on the one or more identified document blocks utilizing the machine-learned large language model to obtain the language output, wherein the language output comprises a summary of the one or more identified document blocks.

[0276] Implementation 50: The computer-implemented method of any of implementations 41-47, wherein the selected task element is associated with a simplification task of the plurality of tasks; and wherein processing the prompt to perform the task based on the one or more identified document blocks utilizing the machine-learned large language model comprises:

[0277] processing, by the computing system, the prompt based on the one or more identified document blocks utilizing the machine-learned large language model to obtain the language output; and

[0278] generating, by the computing system, a simplified language output describing a simplified representation of the language output using the machine-learned large language model.

[0279] Implementation 51: The computer-implemented method of any of implementations 41-47, wherein the selected task element is associated with a counterpoint task of the plurality of tasks; and wherein processing the prompt to perform the task based on the one or more identified document blocks utilizing the machine-learned large language model comprises:

[0280] processing, by the computing system, the prompt based on the one or more identified document blocks utilizing the machine-learned large language model to obtain the language output, wherein the language output describes a point of view; and

[0281] generating, by the computing system, a second language output describing a second point of view that is opposite the point of view using the machine-learned large language model.

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

[0283] one or more processors; and

[0284] one or more non-transitory computer-readable media collectively storing instructions that, when executed by the one or more processors, cause the computer system to perform operations comprising:

[0285] obtaining user interaction information indicating:

[0286] a text query comprising at least a portion of a set of text generated by a user through interaction with a text edit field of a user interface, wherein the user interface includes the text edit field and a plurality of selectable task elements respectively associated with a plurality of tasks of a machine-learned large language model; and

[0287] a selected task element selected by the user from the plurality of selectable task elements;

[0288] generating a text embedding for the text query using a machine-learned embedding generation model;

[0289] performing a similarity search on the text embedding against a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query;

[0290] processing a prompt based on the one or more identified document blocks with the machine-learned large language model to perform a task of the plurality of tasks associated with the selected task element; and

[0291] obtaining language output generated by the machine-learned large language model based on the processing of the prompt.

[0292] Implementation 53: The computer system of implementation 52, wherein prior to performing the similarity search on the text embedding against the plurality of block embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents, the operations comprise:

[0293] accessing the plurality of block embeddings respectively generated by the machine-learned 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

[0294] obtaining data indicative of one or more selected document subsets of the plurality of document subsets.

[0295] Implementation 54: The computer system of implementation 53, wherein obtaining the data indicative of the one or more selected document subsets comprises obtaining data indicative of a selection of one or more selected document subsets of the plurality of document subsets by the user via interaction with the user interface.

[0296] Implementation 55: The computer system of implementation 53, 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 of the plurality of document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0297] Implementation 56: The computer system of implementation 55, wherein the operations further comprise 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 comprises providing provenance information for display within the user interface, wherein the provenance information identifies documents of the one or more selected document subsets that include an identified document block of the one or more identified document blocks.

[0298] Implementation 57: The computer system of any one of implementations 52-56, wherein the text query comprises a second text query received after a prior text query, and wherein the second text query is responsive to a previous language output based on the prior text query.

[0299] Implementation 58: The computer system of any one of implementations 52-56, wherein the selected task element is associated with an idea expansion task of the plurality of tasks, and wherein the one or more identified document blocks comprise a plurality of identified document blocks; and wherein processing the prompt to perform the task based on the one or more identified document blocks with the machine-learned large language model comprises, for a plurality of iterations, processing a prompt based on a different subset of identified document blocks of the plurality of identified document blocks to obtain a respective plurality of outputs, wherein the language output comprises at least some of the plurality of outputs.

[0300] Implementation 59: The computer system of any of implementations 52-56, wherein the selected task element is associated with a summarization task of the plurality of tasks; and wherein processing the prompt based on the one or more identified document blocks to perform the task with the machine-learned large language model comprises:

[0301] processing the prompt based on the one or more identified document blocks to obtain the language output with the machine-learned large language model; and

[0302] generating the language output of the summary using the machine-learned large language model.

[0303] 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 comprising:

[0304] obtaining user interaction information indicating:

[0305] a text query comprising at least a portion of a set of text generated by a user through interaction with a text edit field of a user interface, wherein the user interface includes the text edit field and a plurality of selectable task elements respectively associated with a plurality of tasks of a machine-learned large language model; and

[0306] a selected task element selected by the user from the plurality of selectable task elements;

[0307] generating a text embedding of the text query using a machine-learned embedding generation model;

[0308] performing a similarity search on the text embedding against a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query;

[0309] processing a prompt based on the one or more identified document blocks to perform a task of the plurality of tasks associated with the selected task element with the machine-learned large language model; and

[0310] Obtain the language output generated by the large language model obtained through machine learning based on the processing of the prompts.

[0311] Implementation 61: A computer-implemented method for dynamic task selection for large language models, the method comprising:

[0312] A computing system comprising one or more computing devices obtains user interaction information indicating a text query, the 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;

[0313] The computing system uses a machine learning-based embedding generation model to generate the text embedding for the text query.

[0314] The computing system performs a similarity search on the text embedding 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;

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

[0316] The computing system processes prompts based on the one or more identified document blocks using the machine learning-based large language model to perform the first task among the plurality of tasks; and

[0317] The computing system obtains the language output generated by the large-scale language model through machine learning based on the processing of the prompts.

[0318] Implementation 62: A computer-implemented method as described in 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:

[0319] The computing system accesses 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 the plurality of document subsets; and

[0320] obtaining, by the computing system, data indicative of one or more selected document subsets of the plurality of document subsets.

[0321] Implementation 63: The computer-implemented method of implementation 62, wherein obtaining the data indicative of the one or more selected document subsets comprises obtaining, by the computing system, data indicative of a selection of one or more selected document subsets of the plurality of document subsets by the user via interaction with the user interface.

[0322] Implementation 64: The computer-implemented method of any of implementations 62-63, wherein performing the similarity search on the text embedding comprises performing, by the computing system, 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 of the plurality of document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0323] Implementation 65: The computer-implemented method of implementation 64, wherein the method further comprises providing, by the computing system, the linguistic output for display within a user interface associated with a word processing application.

[0324] Implementation 66: The computer-implemented method of implementation 65, wherein providing the linguistic output for display within the user interface further comprises providing, by the computing system, provenance information for display within the user interface, wherein the provenance information identifies documents of the one or more selected document subsets that include an identified document block of the one or more identified document blocks.

[0325] Implementation 67: The computer-implemented method of any of implementations 61-66, wherein the text query comprises a second text query received after a prior text query, and wherein the second text query is responsive to a previous linguistic output based on the prior text query.

[0326] Implementation 68: The computer-implemented method of any of implementations 61-67, wherein selecting the first task of the plurality of tasks for the machine-learned 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:

[0327] determining, by the computing system, a complexity measure descriptive of a degree of complexity associated with the text query and / or the one or more identified document blocks;

[0328] making, by the computing system, a determination that the complexity measure is greater than a threshold complexity level; and

[0329] selecting, by the computing system, a simplified task of the plurality of tasks for the machine-learned large language model based on the determination.

[0330] Implementation 69: The computer-implemented method of implementation 68, wherein processing, with the machine-learned large language model, the prompt based on the one or more identified document blocks to perform the task comprises:

[0331] processing, by the computing system, the prompt with the machine-learned large language model based on the one or more identified document blocks to obtain the language output; and

[0332] generating, by the computing system, a simplified language output describing a simplified representation of the language output using the machine-learned large language model.

[0333] Implementation 70: The computer-implemented method of implementation 69, wherein the method further comprises displaying, by the computing system, the simplified language output proximate to the language output within the user interface.

[0334] Implementation 71: The computer-implemented method of implementation 69, wherein the method further comprises displaying, by the computing system, the simplified language output within a second user interface different from the user interface.

[0335] Implementation 72: The computer-implemented method of implementation 69, wherein the method further comprises displaying, by the computing system, the simplified language output in place of the language output within the user interface.

[0336] Implementation 73: The computer-implemented method of any of implementations 61-67, wherein selecting the first task of the plurality of tasks for the machine-learned 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:

[0337] making, by the computing system, a determination that the text query and / or the one or more identified document blocks include opinion-expressing textual content; and

[0338] selecting, by the computing system, an opposing viewpoint task of the plurality of tasks for the machine-learned large language model based on the determining.

[0339] Implementation 74: The computer-implemented method of implementation 73, wherein processing, with the machine-learned large language model, the prompt based on the one or more identified document blocks to perform the task comprises:

[0340] processing, by the computing system, the prompt based on the one or more identified document blocks with the machine-learned large language model to obtain the language output, wherein the language output describes a viewpoint; and

[0341] generating, by the computing system, a second language output using the machine-learned large language model, the second language output describing a second viewpoint that is opposite the viewpoint.

[0342] Implementation 75: The computer-implemented method of any of implementations 61-67, wherein the first task is an idea expansion task, and wherein the one or more identified document blocks comprise a plurality of identified document blocks; and wherein processing, with the machine-learned large language model, the prompt based on the one or more identified document blocks to perform the task comprises, for a plurality of iterations, processing, by the computing system, a new prompt to obtain an updated language output, wherein the new prompt is based on one or more of: (a) a subset of the plurality of identified document blocks or (b) a previously updated language output.

[0343] Implementation 76: A computer system for dynamic selection of tasks for a large language model, the computer system comprising:

[0344] one or more processors; and

[0345] one or more non-transitory computer-readable media collectively storing instructions that, when executed by the one or more processors, cause the computer system to perform operations comprising:

[0346] obtaining user interaction information indicative of a text query, the text query comprising at least a portion of a set of text generated by a user through interaction with a text edit field of a user interface; and

[0347] generating a text embedding for the text query using a machine-learned embedding generation model;

[0348] performing a similarity search on the text embedding against a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query;

[0349] selecting, based at least in part on the text query or at least one of the one or more identified document blocks, a first task of a plurality of tasks for a machine-learned large language model; and

[0350] processing, with the machine-learned large language model, a prompt based on the one or more identified document blocks to perform the first task of the plurality of tasks; and

[0351] obtaining language output generated by the machine-learned large language model based on the processing of the prompt.

[0352] Implementation 77: The computer system of implementation 76, wherein prior to performing the similarity search on the text embedding against the plurality of block embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents, the operations comprise:

[0353] accessing the plurality of block embeddings respectively generated by the machine-learned 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

[0354] obtaining data indicative of one or more selected document subsets of the plurality of document subsets.

[0355] Implementation 78: The computer system of implementation 77, wherein obtaining the data indicative of the one or more selected document subsets comprises obtaining data indicative of a selection of one or more selected document subsets of the plurality of document subsets by the user via interaction with the user interface.

[0356] Implementation 79: The computer system of any of implementations 77-78, 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 of the plurality of document blocks included in the one or more selected document subsets as semantically similar to the text query.

[0357] 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 comprising:

[0358] obtaining user interaction information indicative of a text query, the text query including at least a portion of a set of text generated by a user through interaction with a text edit field of a user interface; and

[0359] generating a text embedding for the text query using a machine-learned embedding generation model;

[0360] performing a similarity search on the text embedding against a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query;

[0361] selecting, based at least in part on the text query or at least one of the one or more identified document blocks, a first task of a plurality of tasks for a machine-learned large language model; and

[0362] processing, with the machine-learned large language model, a prompt based on the one or more identified document blocks to perform the first task of the plurality of tasks; and

[0363] obtaining language output generated by the machine-learned large language model based on the processing of the prompt.

Claims

1. A computer-implemented method for semantic exploration of a specified subset of a plurality of documents, the method comprising: receiving, by a computing system comprising one or more computing devices, data indicative of a textual query; generating, by the computing system, a textual embedding of the textual query using a machine-learned embedding generation model; accessing, by the computing system, a plurality of block embeddings respectively generated by the machine-learned embedding generation model for a plurality of document blocks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets; obtaining, by the computing system, data indicative of one or more selected document subsets of the plurality of document subsets; performing, by the computing system, a similarity search of the textual embedding against only block embeddings associated with document blocks included in the one or more selected document subsets, wherein the similarity search identifies one or more of the block embeddings as semantically similar to the textual query; and providing, by the computing system, for display within a user interface, one or more of the plurality of document blocks corresponding to the one or more of the block embeddings identified by the similarity search.

2. The computer-implemented method of claim 1, wherein the user interface comprises a text editing interface associated with a word processing application.

3. The computer-implemented method of claim 2, wherein: the user interface comprises a main text editing field that enables a user of the user interface to generate a set of text; and the textual query comprises at least a portion of the set of text generated by the user through interaction with the main text editing field.

4. The computer-implemented method of claim 2, wherein the user interface comprises: a main text editing field that enables a user of the user interface to generate a set of text; and a query field separate from the main text editing field that enables the user to input the textual query separate from the set of text.

5. The computer-implemented method of any preceding claim, wherein the one or more selected document subsets are specified by the user.

6. The computer-implemented method of claim 5, wherein the user interface comprises a document subset selection tool that enables the user to provide user input to select the one or more selected document subsets from the plurality of document subsets.

7. The computer-implemented method of claim 6, wherein the document subset selection tool provides a graphical representation of the plurality of document subsets.

8. The computer-implemented method of claim 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 application of the filtering logic selects the one or more selected document subsets from the plurality of document subsets.

9. The computer-implemented method of any preceding claim, wherein at least some of the documents included in the one or more selected document subsets comprise documents supplied by the user. ​ 10. The computer-implemented method of any preceding claim, wherein at least some of the documents included in the one or more selected document subsets comprise: a book; a product manual; a legal opinion; an academic paper; a proprietary data file; or a patent document.

11. The computer-implemented method of any preceding claim, further comprising: obtaining, by the computing system, the plurality of documents; parsing, by the computing system, the plurality of documents into the plurality of document chunks; and generating, by the computing system, the plurality of chunk embeddings using the machine- learned embedding generation model.

12. A computer system for semantic exploration of a specified subset of a plurality of documents, the computer system comprising: one or more processors; and one or more non-transitory computer-readable media collectively storing: a plurality of chunk embeddings respectively generated by a machine-learned embedding generation model for a plurality of document chunks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets; and instructions that, when executed by the one or more processors, cause the computer system to perform operations comprising: receiving data indicative of a text query; generating, using the machine-learned embedding generation model, a text embedding for the text query; obtaining data indicative of one or more selected document subsets of the plurality of document subsets; performing a similarity search of the text embedding against only chunk embeddings associated with document chunks included in the one or more selected document subsets, wherein the similarity search identifies one or more of the chunk embeddings as semantically similar to the text query; and providing one or more of the plurality of document chunks corresponding to the one or more of the chunk embeddings identified by the similarity search for display within a user interface.

13. The computer system of claim 12, wherein the user interface comprises a text editing interface associated with a word processing application.

14. The computer system of claim 13, wherein: the user interface comprises a main text editing field that enables a user of the user interface to generate a set of text; and the text query comprises at least a portion of the set of text generated by the user through interaction with the main text editing field.

15. The computer system of claim 13, wherein the user interface comprises: a main text editing field that enables a user of the user interface to generate a set of text; and a query field separate from the main text editing field that enables the user to input the text query separate from the set of text.

16. The computer system of any of claims 12 to 15, wherein the one or more selected document subsets are specified by the user. ​ ​ ​ 17. The computer system of claim 16, wherein the user interface comprises a document subset selection tool that enables the user to provide user input to select the one or more selected document subsets from the plurality of document subsets.

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

19. The computer system of claim 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 application of the filtering logic selects the one or more selected document subsets from the plurality of document subsets.

20. The computer system of any one of claims 12 to 19, wherein the operations further comprise: obtaining the plurality of documents; parsing the plurality of documents into the plurality of document chunks; and generating the plurality of chunk embeddings using the machine-learned embedding generation model.

21. A computer-implemented method for large language model interaction with improved interpretability, the method comprising: receiving, by a computing system comprising one or more computing devices, data indicative of a text query; generating, by the computing system, a text embedding for the text query using a machine-learned embedding generation model; performing, by the computing system, a similarity search on the text embedding against a plurality of chunk embeddings respectively generated by the machine-learned embedding generation model for a plurality of document chunks of a plurality of documents, wherein the similarity search identifies one or more identified document chunks of the plurality of document chunks as semantically similar to the text query; generating, by the computing system, a prompt comprising the one or more identified document chunks; providing, by the computing system, the prompt as input to and for processing by a machine-learned large language model; receiving, by the computing system, language output generated by the machine-learned large language model based on the processing of the prompt; and providing, by the computing system, the language output as output. prior to performing the similarity search on the text embedding against the plurality of chunk embeddings respectively generated by the machine-learned embedding generation model for the plurality of document chunks of the plurality of documents, the method comprises:

22. The computer-implemented method of claim 21, wherein, accessing, by the computing system, the plurality of chunk embeddings respectively generated by the machine-learned embedding generation model for the plurality of document chunks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets.

23. The computer-implemented method of claim 22, wherein accessing the plurality of chunk embeddings respectively generated by the machine-learned embedding generation model for the plurality of document chunks of the plurality of documents further comprises: obtaining, by the computing system, data indicative of one or more selected document subsets of the plurality of document subsets.

24. The computer-implemented method of claim 23, wherein performing the similarity search on the text embedding comprises: ​ performing, by the computing system, a similarity search on the text embedding only with respect to 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 of the plurality of 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 providing the language output as output comprises providing, by the computing system, the language output 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 comprises providing, by the computing system, provenance information for display within the user interface, wherein the provenance information identifies documents of the one or more selected document subsets that include an identified document block of the one or more identified document blocks.

27. The computer-implemented method of claim 26, wherein the provenance information describes a location of the identified document block within the document.

28. The computer-implemented method of claim 25, wherein the user interface comprises a main text edit field that enables a user of the user interface to generate a set of text; and the text query comprises at least a portion of the set of text generated by the user through interaction with the main text edit field.

29. The computer-implemented method of claim 28, wherein the one or more selected document subsets are specified by the user.

30. The computer-implemented method of any of claims 28-29, wherein the method further comprises: receiving, by the computing system, data indicative of a second text query comprising at least a portion of a second set of text generated by the user through interaction with the main text edit field, wherein the second set of text is responsive to the language output.

31. The computer-implemented method of claim 30, wherein the method further comprises: generating, by the computing system, a second text embedding for the second text query using the machine-learned embedding generation model; performing, by the computing system, a second similarity search on the second text embedding only with respect to block embeddings associated with document blocks 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 of the document blocks included in the one or more second document subsets as semantically similar to the second text query; generating, by the computing system, a second prompt comprising the one or more second identified document blocks; providing, by the computing system, the second prompt as input to and for processing by the machine-learned large language model; receiving, by the computing system, a second language output generated by the machine-learned large language model based on the processing of the second prompt; and providing, by the computing system, the second language output for display within the user interface associated with the word processing application.

32. The computer-implemented method of claim 31, wherein, prior to performing the second similarity search of the second text embedding against the block embeddings associated with the document blocks included in the one or more second document subsets, the method comprises: obtaining, by the computing system, information indicative of a selection of the one or more second document subsets from the plurality of document subsets by the user.

33. The computer-implemented method of claim 32, wherein the user interface comprises a document subset selection tool that enables the user to provide user input to select the one or more selected document subsets from the plurality of document subsets.

34. The computer-implemented method of claim 33, wherein the document subset selection tool provides a graphical representation of the plurality of document subsets.

35. The computer-implemented method of claim 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 application of the filtering logic selects the one or more selected document subsets from the plurality of document subsets.

36. The computer-implemented method of claim 31, wherein, prior to performing the second similarity search of the second text embedding against the block embeddings associated with the document blocks included in the one or more second document subsets, the method comprises: selecting, by the computing system, the one or more second document subsets from the plurality of document subsets based at least in part on the second set of text generated by the user.

37. A computer system for large language model interaction with improved interpretability, the computer system comprising: one or more processors; and one or more non-transitory computer-readable media collectively storing instructions that, when executed by the one or more processors, cause the computer system to perform operations comprising: receiving data indicative of a text query; generating, using a machine-learned embedding generation model, a text embedding for the text query; performing a similarity search of the text embedding against a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query; generating a prompt comprising the one or more identified document blocks; providing the prompt as input to and for processing by a machine-learned large language model; receiving language output generated by the machine-learned large language model based on the processing of the prompt; and providing the language output as output.

38. The computer system of claim 37, wherein, prior to performing the similarity search of the text embedding against the plurality of block embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents, the operations comprise: accessing the plurality of block embeddings respectively generated by the machine-learned 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.

39. The computer system of claim 38, wherein accessing the plurality of block embeddings respectively generated by the machine-learned embedding generation model for the plurality of document blocks of the plurality of documents further comprises: obtaining data indicative of one or more selected document subsets of the plurality of document subsets.

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 comprising: receiving data indicative of a text query; generating a text embedding for the text query using a machine-learned embedding generation model; performing a similarity search of the text embedding against a plurality of block embeddings respectively generated by the machine-learned 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 of the plurality of document blocks as semantically similar to the text query; generating a prompt comprising the one or more identified document blocks; providing the prompt as input to and for processing by a machine-learned large language model; receiving language output generated by the machine-learned large language model based on the processing of the prompt; providing the language output as output.

Images