Optimizing the selection of language tasks to improve interaction with large-scale language models.

Abstract

(a) A text query and (b) user interaction information indicating the selected task element selected by the user from multiple selectable task elements are obtained. Text embeddings for the text query are generated using a machine learning-based embedding generation model. A similarity search of text embeddings is performed on multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents. The similarity search identifies identified document chunks (or more) from among the multiple document chunks as semantically similar to the text query. Prompts are processed based on the identified document chunks (or more) using a large-scale language model to execute the task associated with the selected task element. Language output is generated using the large-scale language model based on the processing of the prompts.

Description

Technical Field

[0001] The present disclosure generally relates to optimizing task performance using large language models. More specifically, the present disclosure relates to optimizing the interaction between a user and a large language model while selecting tasks for the large language model.

Background Art

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

Summary of the Invention

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

[0004] One exemplary aspect of the present disclosure relates to a computer-implemented method for improving user interaction with a large-scale language model by facilitating the selection of a particular language task. The method includes obtaining user interaction information by a computing system including one or more computing devices, the user interaction information including (a) a text query comprising at least a portion of a set of text generated by a user through interaction with a text editing field of a user interface, the user interface comprising a text editing field and a plurality of selectable task elements, each associated with a plurality of tasks of a machine-learned large-scale language model, and (b) selected task elements selected by the user from the plurality of selectable task elements. The method includes generating text embeddings for the text query by the computing system using a machine-learned embedding generation model. The method includes performing a text embedding similarity search by the computing system with respect to a plurality of chunk embeddings generated by the machine-learned embedding generation model for a plurality of document chunks of a plurality of documents, the similarity search identifying one or more identified document chunks of the plurality of document chunks as semantically similar to the text query. The method includes a computing system processing prompts based on one or more identified document chunks using a machine learning-trained large-scale language model to perform tasks associated with selected task elements among multiple tasks. The method also includes a computing system obtaining language output generated by the machine learning-trained large-scale language model based on the processing of prompts.

[0005] One exemplary aspect of the present disclosure relates to a computer system for facilitating the selection of a particular language task and improving user interaction with a large language model. The computer system includes one or more processors and one or more non-temporary computer-readable media that, when executed by one or more processors, collectively store instructions causing the computer system to perform an action. The action includes obtaining user interaction information, the user interaction information being (a) a text query comprising at least a portion of a set of text generated by the user through interaction with a text editing field of a user interface, the user interface comprising a text editing field and a plurality of selectable task elements, each associated with a plurality of tasks of a machine-learned large language model, and (b) selected task elements selected by the user from the plurality of selectable task elements. The action includes generating text embeddings for the text query using a machine-learned embedding generation model. The operation involves performing a text embedding similarity search on multiple chunk embeddings generated by a machine learning-based embedding generation model for multiple document chunks of multiple documents, the similarity search identifying one or more identified document chunks among the multiple document chunks as semantically similar to the text query. The operation involves processing prompts based on one or more identified document chunks using a machine learning-based large-scale language model to perform tasks associated with selected task elements among multiple tasks. The operation involves obtaining language output generated by the machine learning-based large-scale language model based on the processing of prompts.

[0006] Other exemplary aspects of the present disclosure relate to one or more non-temporary computer-readable media that, when executed by one or more processors of a computing system, store instructions causing the computing system to perform an action. The action includes obtaining user interaction information, which includes (a) a text query comprising at least a portion of a set of text generated by the user through interaction with a text editing field of a user interface, wherein the user interface comprises a text editing field and a plurality of selectable task elements, each associated with a plurality of tasks of a machine-learned large-scale language model, and (b) selected task elements selected by the user from the plurality of selectable task elements. The action includes generating text embeddings for the text query using a machine-learned embedding generation model. The action includes performing a text embedding similarity search with respect to a plurality of chunk embeddings 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. The operation involves processing prompts based on one or more identified document chunks using a machine learning-trained large-scale language model to perform tasks associated with selected task elements among multiple tasks. The operation also involves obtaining language output generated by the machine learning-trained large-scale language model based on the prompt processing.

[0007] Other exemplary aspects of this disclosure relate to computer-implemented methods for dynamic task selection for large-scale language models. The method includes a computing system, comprising one or more computing devices, obtaining user interaction information indicating a text query that includes at least a portion of a set of text generated by a user through interaction with a text editing field of a user interface. The method includes the computing system generating text embeddings for the text query using a machine learning-trained embedding generation model. The method includes the computing system performing a text embedding similarity search with respect to a plurality of chunk embeddings generated by the machine learning-trained embedding generation model for a plurality of document chunks of a plurality of documents, the similarity search including identifying one or more identified document chunks of the plurality of document chunks as semantically similar to the text query. The method includes the computing system selecting a first task of a plurality of tasks for a machine learning-trained large-scale language model at least in part on the text query or at least one of the one or more identified document chunks. The method includes the computing system processing prompts based on one or more identified document chunks using the machine learning-trained large-scale language model in order to perform the first task of the plurality of tasks. The method involves a computing system obtaining language output generated by a machine learning-prepared large-scale language model based on the processing of prompts.

[0008] Other exemplary aspects of this disclosure relate to a computer system for dynamic task selection for large-scale language models. The computer system includes one or more processors and one or more non-temporary computer-readable media that, when executed by one or more processors, collectively store instructions causing the computer system to perform an action. The action includes obtaining user interaction information indicating a text query, which includes at least a portion of a set of text generated by the user through interaction with a text editing field of a user interface. The action includes generating text embeddings for the text query using a machine learning-based embedding generation model. The action includes performing a text embedding similarity search with respect to a plurality of chunk embeddings generated by the machine learning-based embedding generation model for a plurality of document chunks of a plurality of documents, the similarity search identifying one or more identified document chunks of the plurality of document chunks as semantically similar to the text query. The action includes selecting a first task of a plurality of tasks for a machine learning-based large-scale language model, at least in part, based on the text query or at least one of the one or more identified document chunks. The operation involves processing a prompt based on one or more identified document chunks using a machine learning-trained large-scale language model to perform the first of several tasks. The operation also involves obtaining the language output generated by the machine learning-trained large-scale language model based on the prompt processing.

[0009] Other exemplary aspects of this disclosure relate to one or more non-temporary computer-readable media that, when executed by one or more processors of a computing system, store instructions causing the computing system to perform an action. The action includes obtaining user interaction information indicating a text query, which includes at least a portion of a set of text generated by a user through interaction with a text editing field of a user interface. The action includes generating text embeddings for the text query using a machine learning-trained embedding generation model. The action includes performing a text embedding similarity search with respect to a plurality of chunk embeddings generated by the machine learning-trained embedding generation model for a plurality of document chunks of a plurality of documents, the similarity search identifying one or more identified document chunks of the plurality of document chunks as semantically similar to the text query. The action includes selecting a first task of a plurality of tasks for a machine learning-trained large-scale language model based at least in part on the text query or at least one of the one or more identified document chunks. The action includes processing prompts based on one or more identified document chunks using the machine learning-trained large-scale language model in order to perform the first task of the plurality of tasks. The operation involves obtaining language output generated by a machine learning-prepared large-scale language model based on the processing of prompts.

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

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

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

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

Best Mode for Carrying Out the Invention

[0014] Reference numerals repeated across multiple drawings are intended to identify the same features in various embodiments.

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

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

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

[0018] Furthermore, or in some embodiments, the computing system can use the identified document chunk(s) as input to a large-scale language model to provide more information to the user. For example, the computing system can generate a prompt containing the identified document chunk(s). The computing system can provide the prompt as input to a machine-learned large-scale language model (for example, by processing the prompt with the model and providing the prompt to a remote service implementing the model) and receive the language output generated by the model. The language output may be provided to the user.

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

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

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

[0022] Exemplary embodiments of this disclosure will be described in further detail here with reference to the drawings.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[0039] The training computing system 150 may include a model trainer 160 that trains machine-learned models 120 and / or 140 stored in the user computing device 102 and / or server computing system 130 using various training or learning techniques, such as backpropagation. For example, a loss function may be backpropagated through the model(s) to update one or more parameters of the model(s) (for example, 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. The parameters can be iteratively updated for several training iterations using gradient descent techniques.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[0056] Figure 1C shows a block diagram of an exemplary computing device 50 according to an exemplary embodiment of the present disclosure, which facilitates the selection of specific language tasks to improve user interaction with a large language model. The computing device 50 may be a user computing device or a server computing device.

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

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

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

[0060] Exemplary model placement Figure 2 shows a block diagram of an exemplary machine-learned large language model 200 according to an exemplary embodiment of the present disclosure. In some embodiments, the machine-learned large language model 200 is trained to receive a set of input data 204 which is or describes an identified document chunk(s), and as a result of receiving the input data 204, is trained to provide output data 206 which describes a language output.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[0116] In some embodiments, the computing system can provide language output for display within a user interface associated with a word processing application. In some embodiments, providing language output for display within a user interface may further include providing attribute information for display within the user interface, the attribute information identifying a document that includes one identified document chunk from one or more identified document chunks of one or more document subsets.

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

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

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

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

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

[0122] Figure 12 shows a flowchart of an exemplary method 1200 for performing dynamic task selection for a large language model according to an exemplary embodiment of the present disclosure. While Figure 12 shows the steps performed in a specific order for illustrative and explanatory purposes, the methods of the present disclosure are not limited to the specifically shown order or arrangement. Various steps of method 1200 can be omitted, rearranged, rearranged, and / or adapted in various ways without departing from the scope of the present disclosure.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[0137] Embodiment 6: The computer-based method according to Embodiment 5, wherein the user interface includes a document subset selection tool, which enables the user to provide user input for selecting one or more selected document subsets from the plurality of document subsets.

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

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

[0140] Embodiment 9: A method implemented on a computer according to any one of Embodiments 1 to 8, wherein at least a portion of the documents included in the one or more selected subsets of documents includes documents supplied by the user.

[0141] Embodiment 10: At least a portion of the documents included in the one or more selected document subsets is ·Books, Product manual, ·Legal opinion; • Academic papers, • Proprietary data files, or • Patent documents A method implemented in a computer according to any one of embodiments 1 to 9, including the above.

[0142] Embodiment 11 The computing system acquires the multiple documents, The computing system performs syntactic analysis of the multiple documents into the multiple document chunks, The computing system generates the multiple chunk embeddings using the machine learning-prepared embedding generation model. A computer implementation method according to any one of embodiments 1 to 10, further including the above.

[0143] Embodiment 12: A computer system for semantic search of a specified subset of multiple documents, wherein the computer system is • One or more processors, • Includes one or more non-temporary computer-readable media, wherein the one or more non-temporary computer-readable media are o Multiple chunk embeddings generated by a machine learning-based embedding generation model for multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets, and oWhen executed by one or more processors, the system collectively stores instructions that cause the computing system to perform an operation, and the operation is, A computing system including one or more computing devices receives data indicating a text query, The computing system generates text embeddings for the text query using the machine learning-prepared embedding generation model, The computing system obtains data indicating one or more selected document subsets from the plurality of document subsets, The computing system includes performing a similarity search of the text embeddings with respect only to chunk embeddings associated with document chunks contained in the one or more selected subsets of documents, wherein the similarity search identifies one or more of the chunk embeddings as semantically similar to the text query, and the operation further includes: - To provide the computing system with one or more of the multiple document chunks corresponding to one or more of the chunk embeddings identified by the similarity search, for display within the user interface. A computer system, including a computer system.

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

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

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

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

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

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

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

[0151] Embodiment 20: The above operation is, The computing system acquires the multiple documents, The computing system performs syntactic analysis of the multiple documents into the multiple document chunks, The computing system generates the multiple chunk embeddings using the machine learning-prepared embedding generation model. A computer system according to any one of embodiments 12 to 19, further including the above.

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

[0153] Embodiment 22: The method, implemented on a computer according to Embodiment 21, wherein, before performing the similarity search of the text embeddings with respect to the chunk embeddings generated by the machine learning-based embedding generation model for each of the document chunks of the plurality of documents, the method includes, by having the computing system access the chunk embeddings generated by the machine learning-based embedding generation model for each of the document chunks of the plurality of documents, wherein the plurality of documents are organized into a plurality of document subsets.

[0154] Embodiment 23: Accessing the plurality of chunk embeddings generated by the machine learning-prepared embedding generation model for each of the plurality of document chunks of the plurality of documents is a method implemented on a computer according to Embodiment 22, further comprising the computing system obtaining data representing one or more selected document subsets of the plurality of document subsets.

[0155] Embodiment 24: Performing the similarity search of text embeddings is a method implemented on a computer according to Embodiment 23, wherein the computing system performs the similarity search of text embeddings with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, the similarity search identifies one or more identified document chunks among the plurality of document chunks contained in the one or more selected document subsets as semantically similar to the text query.

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

[0157] Embodiment 26: Providing the language output for display within the user interface further comprises the computing system providing attribute information for display within the user interface, wherein the attribute information identifies a document that includes one identified document chunk from one or more identified document chunks among the one or more selected subsets of documents, a method implemented in a computer according to Embodiment 25.

[0158] Embodiment 27: A method implemented in a computer according to Embodiment 26, wherein the attribute information describes the location of the identified document chunk within the document.

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

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

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

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

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

[0164] Embodiment 33: The method implemented on a computer according to Embodiment 32, wherein the user interface includes a document subset selection tool, the tool enabling the user to provide user input for selecting one or more selected document subsets from the plurality of document subsets.

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

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

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

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

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

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

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

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

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

[0174] Embodiment 43: A method implemented in a computer according to Embodiment 42, wherein obtaining the data indicating the one or more selected document subsets includes the computing system obtaining data indicating the selection of one or more selected document subsets from the plurality of document subsets through the user's interaction with the user interface.

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

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

[0177] Embodiment 46: Providing the language output for display within the user interface further comprises the computing system providing attribute information for display within the user interface, wherein the attribute information identifies a document that includes one identified document chunk from one or more identified document chunks of the one or more selected subsets of documents, a method implemented in a computer according to Embodiment 45.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[0194] Embodiment 63: A method implemented in a computer according to Embodiment 62, wherein obtaining the data indicating the one or more selected document subsets includes obtaining data indicating the selection of one or more selected document subsets from the plurality of document subsets through interaction by the user with the user interface.

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

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

[0197] Embodiment 66: Providing the language output for display within the user interface further comprises the computing system providing attribute information for display within the user interface, wherein the attribute information identifies a document that includes one identified document chunk from one or more identified document chunks among one or more selected subsets of documents, a method implemented in a computer according to Embodiment 65.

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

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

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

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

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

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

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

[0205] Embodiment 74: Processing the prompt based on one or more identified document chunks using the machine learning-trained large language model to perform the task is: The computing system includes processing the prompt based on one or more identified document chunks using the machine-learned large-scale language model to obtain the language output, the language output describing the viewpoint, and processing the prompt further includes: The computing system includes using the machine-trained large-scale language model to generate a second language output that describes a second perspective opposite to the aforementioned perspective. A method implemented in a computer as described in Embodiment 73.

[0206] Embodiment 75: The first task is an idea expansion task, the one or more identified document chunks comprising a plurality of identified document chunks, and processing the prompts based on the one or more identified document chunks using the machine-trained large language model to perform the task comprises, for a plurality of iterations, processing new prompts by the computing system to obtain updated language output, the new prompts based on one or more of (a) a subset of identified document chunks from the plurality of identified document chunks, or (b) previous updated language output, as implemented on a computer according to any one of Embodiments 61 to 67.

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

[0208] Embodiment 77: Before performing the similarity search of the text embeddings with respect to the chunk embeddings generated by the machine learning-prepared embedding generation model for each of the document chunks of the plurality of documents, the operation is as follows: The operation further includes accessing the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for the multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets, and the operation further includes This includes obtaining data that indicates one or more selected document subsets from the plurality of document subsets, The computer system according to embodiment 76.

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

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

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

Claims

1. A computer-implemented method for facilitating the selection of a specific language task in order to improve user interaction with a large-scale language model, wherein the method is The acquisition of user interaction information by a computing system including one or more computing devices, wherein the user interaction information is (a) A text query comprising at least a portion of a set of text generated by a user through interaction with a text editing field of a user interface, wherein the user interface comprises the text editing field and a plurality of selectable task elements, each associated with a plurality of tasks of a machine learning-trained large language model, (b) To obtain, the selected task element selected by the user from the plurality of selectable task elements, The computing system generates text embeddings for the text query using a machine learning-based embedding generation model, The computing system performs a text embedding similarity search on multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. The computing system processes prompts based on one or more identified document chunks using the machine learning-trained large-scale language model to execute the task associated with the selected task element among the plurality of tasks, The computing system obtains language output generated by the machine learning-prepared large-scale language model based on the processing of the prompt, A method of implementation in a computer, including the methods mentioned above.

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

3. A method implemented in a computer according to claim 2, wherein obtaining the data indicating the one or more selected document subsets includes, by the computing system, obtaining data indicating the selection of one or more selected document subsets from the plurality of document subsets through interaction by the user with the user interface.

4. Performing the similarity search on the aforementioned text embedding means A computer-implemented method according to claim 2 or 3, comprising: the computing system performing a similarity search for the text embedding with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, wherein the similarity search identifies one or more identified document chunks of the plurality of document chunks contained in the one or more selected document subsets as semantically similar to the text query.

5. The method, implemented on a computer according to claim 4, further comprising the computing system providing the language output for display within a user interface associated with a word processing application.

6. The method implemented in a computer according to claim 5, wherein providing the language output for display within the user interface further includes providing attribute information for display within the user interface by the computing system, the attribute information identifies a document that includes one identified document chunk from one or more identified document chunks of the one or more selected subsets of documents.

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

8. The selected task element is associated with an idea expansion task among the plurality of tasks, and the one or more identified document chunks include a plurality of identified document chunks. To perform the aforementioned task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: A computer-implemented method according to any one of claims 1 to 7, comprising, for a plurality of iterations, processing a new prompt by the computing system to obtain updated language output, wherein the new prompt is based on one or more of (a) a subset of identified document chunks from the plurality of identified document chunks, or (b) previously updated language output.

9. The selected task element is associated with the summary task among the multiple tasks, To perform the aforementioned task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: The computing system includes processing the prompt based on one or more identified document chunks using the machine-learned large-scale language model to obtain the language output, the language output including a summary of the one or more identified document chunks. A method implemented in a computer according to any one of claims 1 to 7.

10. The selected task element is associated with the simplification task among the multiple tasks, To perform the aforementioned task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: The computing system processes the prompt based on one or more identified document chunks using the machine learning-prepared large-scale language model in order to obtain the language output, The computing system uses the machine learning-prepared large-scale language model to generate a simplified language output that describes a simplified representation of the language output. A method implemented in a computer according to any one of claims 1 to 7, including the method described in any one of claims 1 to 7.

11. The selected task element is associated with the dissenting task among the multiple tasks, To perform the aforementioned task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: The computing system processes the prompt based on one or more identified document chunks using the machine-learned large-scale language model to obtain the language output, wherein the language output describes, processes, and The computing system includes using the machine-learned large-scale language model to generate a second language output that describes a second perspective opposite to the aforementioned perspective, A method implemented in a computer according to any one of claims 1 to 7.

12. A computer system for facilitating the selection of specific language tasks in order to improve user interaction with a large-scale language model, wherein the computer system is One or more processors, The system includes one or more non-temporary computer-readable media that, when executed by the one or more processors, collectively store instructions that cause the computer system to perform an operation, and the operation is The acquisition of user interaction information, wherein the user interaction information is (a) A text query comprising at least a portion of a set of text generated by a user through interaction with a text editing field of a user interface, wherein the user interface comprises the text editing field and a plurality of selectable task elements, each associated with a plurality of tasks of a machine learning-trained large language model, (b) To obtain, the selected task element selected by the user from the plurality of selectable task elements, Using a machine learning-based embedding generation model, generate text embeddings for the text query, The process involves performing a text embedding similarity search on multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. Processing prompts based on one or more identified document chunks using the machine learning-trained large-scale language model in order to execute the task associated with the selected task element among the plurality of tasks, The process of the prompts is used to obtain the language output generated by the machine learning-prepared large-scale language model, A computer system, including a computer system.

13. Before performing the similarity search of the text embeddings with respect to the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for each of the multiple document chunks of the multiple documents, the operation is as follows: Accessing the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for each of the multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets, and accessing them. To obtain data indicating one or more selected document subsets from the aforementioned plurality of document subsets, The computer system according to claim 12, including the above.

14. The computer system according to claim 13, wherein obtaining the data indicating one or more selected document subsets includes obtaining data indicating the selection of one or more selected document subsets from the plurality of document subsets through interaction by the user with the user interface.

15. Performing the similarity search on the aforementioned text embedding means The computer system according to claim 13, comprising performing a text embedding similarity search with respect only to 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 among the plurality of document chunks included in the one or more selected document subsets as semantically similar to the text query.

16. The operation further includes providing the language output for display within a user interface associated with a word processing application, The computer system according to claim 15, wherein providing the language output for display within the user interface further includes providing attribute information for display within the user interface, the attribute information identifies a document that includes one identified document chunk from one or more identified document chunks among one or more selected subsets of documents.

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

18. The selected task element is associated with an idea expansion task among the plurality of tasks, and the one or more identified document chunks include a plurality of identified document chunks. To perform the aforementioned task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: For multiple iterations, the process includes processing prompts based on different subsets of the identified document chunks of the multiple identified document chunks to obtain each of the multiple outputs, wherein the language output includes at least a portion of the multiple outputs. The computer system according to any one of claims 12 to 16.

19. The selected task element is associated with the summary task among the multiple tasks, To perform the aforementioned task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: To obtain the language output, the machine learning-prepared large-scale language model is used to process the prompt based on one or more identified document chunks, To generate a summary of the aforementioned language output, the aforementioned machine learning-prepared large-scale language model is used, A computer system according to any one of claims 12 to 16, including the computer system according to any one of claims 12 to 16.

20. One or more non-temporary computer-readable media, which, when executed by one or more processors of a computing system, store instructions that cause the computing system to perform an action, wherein the action is The acquisition of user interaction information, wherein the user interaction information is (a) A text query comprising at least a portion of a set of text generated by a user through interaction with a text editing field of a user interface, wherein the user interface comprises the text editing field and a plurality of selectable task elements, each associated with a plurality of tasks of a machine learning-trained large language model, (b) The selected task element selected by the user from the plurality of selectable task elements, and the acquisition of the selected task element. Using a machine learning-based embedding generation model, generate text embeddings for the text query, The process involves performing a text embedding similarity search on multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. Processing prompts based on one or more identified document chunks using the machine learning-trained large-scale language model in order to execute the task associated with the selected task element among the plurality of tasks, The process of the prompts is used to obtain the language output generated by the machine learning-prepared large-scale language model, One or more non-temporary computer-readable media, including [the specified text].

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

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

23. A computer-implemented method according to claim 22, wherein obtaining the data indicating the one or more selected document subsets includes, by the computing system, obtaining data indicating the selection of one or more selected document subsets from the plurality of document subsets through interaction by the user with the user interface.

24. Performing the similarity search on the aforementioned text embedding means A computer-implemented method according to claim 22 or 23, comprising: the computing system performing a text embedding similarity search with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, wherein the similarity search identifies one or more identified document chunks among the plurality of document chunks contained in the one or more selected document subsets as semantically similar to the text query.

25. The method, as implemented in a computer according to claim 24, further comprising the computing system providing the language output for display within a user interface associated with a word processing application.

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

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

28. Selecting the first task from among the multiple tasks for the machine-learned large-scale language model based at least partially on at least one of the text queries or one or more identified document chunks is: The computing system determines a complexity metric that describes the degree of complexity associated with the text query and / or one or more identified document chunks. The computing system makes a determination that the complexity metric is greater than a complexity threshold, The computing system, based on the decision, selects a simplification task from among the multiple tasks for the machine-learned large-scale language model, A method implemented in a computer according to any one of claims 21 to 27, including the method described in any one of claims 21 to 27.

29. To perform the aforementioned task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: The computing system processes the prompt based on one or more identified document chunks using the machine learning-prepared large-scale language model in order to obtain the language output, The computing system uses the machine learning-prepared large-scale language model to generate a simplified language output that describes a simplified representation of the language output, A method implemented in a computer according to claim 28, including the method described in claim 28.

30. The method, as implemented in a computer according to claim 29, further comprising the computing system displaying the simplified language output within the user interface adjacent to the language output.

31. The method, implemented in a computer according to claim 29, further comprising the computing system displaying the simplified language output in a second user interface different from the user interface.

32. The method, implemented in a computer according to claim 29, further comprising the computing system displaying the simplified language output to replace the language output in the user interface.

33. Selecting the first task from among the multiple tasks for the machine-learned large-scale language model based at least partially on at least one of the text queries or one or more identified document chunks is: The computing system makes a determination that the text query and / or one or more identified document chunks contain text content expressing an opinion. The computing system, based on the decision, selects the dissenting task from among the multiple tasks for the machine-learned large-scale language model. A method implemented in a computer according to any one of claims 21 to 27, including the method described in any one of claims 21 to 27.

34. Processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model to perform the task is: The computing system processes the prompt based on one or more identified document chunks using the machine-learned large-scale language model to obtain the language output, wherein the language output describes, processes, and The computing system includes using the machine-learned large-scale language model to generate a second language output that describes a second perspective opposite to the aforementioned perspective, A method implemented in a computer according to claim 33.

35. The first task described above is an idea expansion task, and the one or more identified document chunks include a plurality of identified document chunks. To perform the aforementioned task, processing the prompt based on one or more identified document chunks using the machine learning-trained large-scale language model is: A computer-implemented method according to any one of claims 21 to 27, comprising, for a plurality of iterations, processing a new prompt by the computing system to obtain updated language output, wherein the new prompt is based on one or more of (a) a subset of identified document chunks from the plurality of identified document chunks, or (b) previously updated language output.

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

37. Before performing the similarity search of the text embeddings with respect to the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for each of the multiple document chunks of the multiple documents, the operation is as follows: Accessing the multiple chunk embeddings generated by the machine learning-prepared embedding generation model for the multiple document chunks of the multiple documents, wherein the multiple documents are organized into multiple document subsets. To obtain data indicating one or more selected document subsets from the aforementioned plurality of document subsets, The computer system according to claim 36, including the computer system according to claim 36.

38. The computer system according to claim 37, wherein obtaining the data indicating one or more selected document subsets includes obtaining data indicating the selection of one or more selected document subsets from the plurality of document subsets through interaction by the user with the user interface.

39. Performing the similarity search on the aforementioned text embedding means The computer system according to claim 37 or 38, comprising performing a text embedding similarity search with respect only to chunk embeddings associated with document chunks contained in the one or more selected document subsets, wherein the similarity search identifies one or more identified document chunks among the plurality of document chunks contained in the one or more selected document subsets as semantically similar to the text query.

40. One or more non-temporary computer-readable media, which, when executed by one or more processors of a computing system, store instructions that cause the computing system to perform an action, wherein the action is Obtaining user interaction information that indicates a text query containing at least a portion of the text set generated by the user through interaction with the text editing field of the user interface, Using a machine learning-based embedding generation model, generate text embeddings for the text query, The process involves performing a text embedding similarity search on multiple chunk embeddings generated by the machine learning-based embedding generation model for multiple document chunks of multiple documents, wherein the similarity search identifies one or more identified document chunks among the multiple document chunks as semantically similar to the text query. Selecting a first task from a plurality of tasks for a machine learning-trained large-scale language model based at least partially on at least one of the text queries or one or more identified document chunks, To perform the first of the aforementioned tasks, the machine learning-trained large-scale language model is used to process prompts based on one or more identified document chunks, The process of the prompts is used to obtain the language output generated by the machine learning-prepared large-scale language model, One or more non-temporary computer-readable media, including [the specified text].

Images