DETAILED ACTION
This action is responsive to claims filed on 22 May 2023.
Claims 1-20 are pending for examination.
Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Claim Objections
Claim 4 and analogous claims 12, 20 is objected to because of the following informalities: “the parse trees” in line 3 and line 7 should be “the private parse trees”. Appropriate correction is required.
Claim 4 and analogous claims 12, 20 is objected to because of the following informalities: “the private user utterances” line 7 should be “the private utterances”. Appropriate correction is required.
Claim Rejections - 35 USC § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
The factual inquiries for establishing a background for determining obviousness under 35 U.S.C. 103 are summarized as follows:
1. Determining the scope and contents of the prior art.
2. Ascertaining the differences between the prior art and the claims at issue.
3. Resolving the level of ordinary skill in the pertinent art.
4. Considering objective evidence present in the application indicating obviousness or nonobviousness.
This application currently names joint inventors. In considering patentability of the claims the examiner presumes that the subject matter of the various claims was commonly owned as of the effective filing date of the claimed invention(s) absent any evidence to the contrary. Applicant is advised of the obligation under 37 CFR 1.56 to point out the inventor and effective filing dates of each claim that was not commonly owned as of the effective filing date of the later invention in order for the examiner to consider the applicability of 35 U.S.C. 102(b)(2)(C) for any potential 35 U.S.C. 102(a)(2) prior art against the later invention.
Claims 1-2, 5, 9-10, 13, 17-18 are rejected under 35 U.S.C. 103 as being unpatentable over Drake et al. (U.S. Grant No. 11024299, hereinafter ‘Drake'), in view of Sapugay et al. (U.S. Pre-Grant Publication No. 20200327284, hereinafter 'Sapugay'), and further in view of Rosenbaum et al. (NPL: "CLASP: Few-Shot Cross-Lingual Data Augmentation for Semantic Parsing", hereinafter 'Rosenbaum').
Regarding claim 1 and analogous claim 9, Drake teaches A computing system comprising:
one or more processors configured to execute instructions stored in memory to ([Col. 14, Line 58-Col. 15, Line 2] To provide privacy and intent-preserving redactions, an example process flow 150 is presented and may be performed, for example, by the utterance detection module 106, the redaction module 110, and/or the redaction delivery module 124. In some embodiments, the utterance detection module 106, the redaction module 110, and/or the redaction delivery module 124 may each include at least one memory that stores computer-executable instructions and at least one processor configured to access the at least one memory and execute the computer-executable instructions to perform various actions or operations, such as one or more of the operations in the process flow 150 of FIG. 1.):
train a differentially private parse tree generation model ([Col. 11, Lines 41-46] In some embodiments, the differentially private exploration tree is build using a public dataset D containing a list of queries Q. In this context, a “public” dataset may include a publicly-available dataset as well as a dataset that is widely available within an organization, but that is not shared externally.; [Col. 21 Lines 7-13] The remote server 500 may be configured to communicate via one or more networks with one or more servers, search engines, user devices, or the like. In some embodiments, a single remote server or single group of remote servers may be configured to perform product collection generation, product collection surfacing, and/or machine learning functionality.)
train a differentially private parse-to-utterance model ([Col. 11, Lines 41-46] In some embodiments, the differentially private exploration tree is build using a public dataset D containing a list of queries Q. In this context, a “public” dataset may include a publicly-available dataset as well as a dataset that is widely available within an organization, but that is not shared externally.; [Col. 21 Lines 7-13] The remote server 500 may be configured to communicate via one or more networks with one or more servers, search engines, user devices, or the like. In some embodiments, a single remote server or single group of remote servers may be configured to perform product collection generation, product collection surfacing, and/or machine learning functionality.)
Drake fails to teach based at least on private parse trees of a private utterance-parse tree dataset; train a differentially private parse tree generation model, train a differentially private parse-to-utterance model based at least on private utterances and corresponding private parse trees of the private utterance-parse tree dataset; generate a synthesized parse tree dataset including synthesized parse trees sampled at random from the trained differentially private parse tree generation model; and generate, a synthesized utterance dataset including synthesized utterances based at least on the synthesized parse trees of the synthesized parse tree dataset, via the trained differentially private parse-to-utterance model
Sapugay teaches based at least on private parse trees of a private utterance-parse tree dataset ([0114] The NLU framework includes a meaning extraction subsystem that is designed to generate meaning representations for the sample utterances of the intent/entity model, as well as a meaning representation for a received user utterance. To generate these meaning representations, the meaning extraction subsystem includes a vocabulary subsystem, a structure subsystem, and a prosody subsystem that cooperate to parse utterances based on combinations of rule-based methods and ML-based methods. Further, for improved accuracy, the meaning extraction subsystem includes a rule-based augmentation error detection subsystem that can cooperate with the vocabulary, structure subsystem, and prosody subsystems to iteratively parse and correct an utterance before meaning representations are generated. The of a private utterance-parse tree dataset meaning representations are a data structure having a form or shape that captures the grammatical structure of the utterance, while based at least on private parse trees subtrees of the data structure capture the semantic meaning of the words and phases of the utterance as vectors that are annotated with additional information (e.g., class information).);
train a differentially private parse tree generation model ([0072] The parse tree generation model meaning extraction subsystem of FIG. 6 itself includes a number of subsystems that cooperate to generate the meaning representations 158 and 162.; [0108] For the example illustrated in FIG. 14, when the meaning extraction subsystem 150 determines in block 328 that a sufficient number (e.g., a majority, greater than a predetermined threshold value) of annotated utterance trees 326 for a particular utterance are substantially the same for a quorum to be reached, then the meaning extraction subsystem 150 may use the quorum-based set of annotated utterance trees 330 to train train and improve a ML-model 322 associated with the ML-based parser 188, as indicated by the arrow 331.)
train a differentially private parse-to-utterance model based at least on private utterances and corresponding private parse trees of the private utterance-parse tree dataset ([0094] Once the meaning representations 158 and 162 have been generated, as illustrated in FIG. 5, the meaning search subsystem 152 can compare these meaning representations to extract intent/entities from the user utterance 122. FIG. 12 is a flow diagram illustrating an example embodiment of a process 280 whereby the parse-to-utterance model meaning search subsystem 152 searches the based at least on private utterances and corresponding private parse trees of the private utterance-parse tree dataset meaning representations 158 of the understanding model 157 for matches to the meaning representation 162 of the user utterance 122 based on information stored in the compilation model template 244. For the embodiment illustrated in FIG. 12, the meaning search subsystem 152 receives the at least one meaning representation 162 of the utterance meaning model 160 generated in FIG. 9, as discussed above. Using the prosody subsystem 174 discussed above, the meaning search subsystem 152 first segments (block 282) the meaning representations 162 into intent subtrees, each representing an atomic intent, based on one or more stored rules 114 (e.g., intent-segmentation rules).; As such, it is appreciated that, by expanding or modifying the word vector distribution model 342, operation of the vocabulary subsystem 170, the NLU framework 104, and the agent automation system 100 can be train improved to handle words with new or changing meanings using only training data that can be generated from a continually growing corpus of utterances 112 of the database 106 illustrated in FIG. 4A. For the example illustrated in FIG. 15, the corpus of utterances 112 may be, for example, a collection of chat logs storing utterances user utterances 122 and agent utterances 124 from various chat room exchanges, or other suitable source data.);
generate, a synthesized utterance dataset including synthesized utterances based at least on the synthesized parse trees of the synthesized parse tree dataset ([0070] The meaning extraction subsystem 150 generates an understanding model 157 that includes meaning representations 158 of the sample utterances 155 of the intent/entity model 108. In other words, the understanding model 157 is a translated or augmented version of the intent/entity model 108 that includes meaning representations 158 to enable searching (e.g., comparison and matching) by the meaning search subsystem 152, as discussed below. As such, it may be appreciated that the right-hand portion 154 of FIG. 6 is generally performed in advance of receiving the user utterance 122, such as on a routine, scheduled basis or in response to updates to the intent/entity model 108.; [0082] For the embodiment illustrated in FIG. 8, the process 210 begins with the meaning extraction subsystem 150 of the NLU framework 104 generating (block 214) the generate, a synthesized utterance dataset including synthesized utterances based at least on the synthesized parse trees of the synthesized parse tree dataset annotated utterance tree 166 from the utterance 168 using one or more ML-based plugins (e.g., ML-based parsers 188 or ML-based prosody systems 196), as discussed above. In certain embodiments, this step may include a preliminary cleansing and augmentation step performed before the annotated utterance tree 166 is generated. For example, in certain embodiments, this preliminary cleansing and augmentation step may involve the vocabulary subsystem 170, the structure subsystem 172, and/or the prosody subsystem 174 modifying the utterance 168 based on the stored rules 114.).
via the trained differentially private parse-to-utterance model ([0094] Once the meaning representations 158 and 162 have been generated, as illustrated in FIG. 5, the meaning search subsystem 152 can compare these meaning representations to extract intent/entities from the user utterance 122. FIG. 12 is a flow diagram illustrating an example embodiment of a process 280 whereby the parse-to-utterance model meaning search subsystem 152 searches the meaning representations 158 of the understanding model 157 for matches to the meaning representation 162 of the user utterance 122 based on information stored in the compilation model template 244. For the embodiment illustrated in FIG. 12, the meaning search subsystem 152 receives the at least one meaning representation 162 of the utterance meaning model 160 generated in FIG. 9, as discussed above. Using the prosody subsystem 174 discussed above, the meaning search subsystem 152 first segments (block 282) the meaning representations 162 into intent subtrees, each representing an atomic intent, based on one or more stored rules 114 (e.g., intent-segmentation rules).; As such, it is appreciated that, by expanding or modifying the word vector distribution model 342, operation of the vocabulary subsystem 170, the NLU framework 104, and the agent automation system 100 can be trained improved to handle words with new or changing meanings using only training data that can be generated from a continually growing corpus of utterances 112 of the database 106 illustrated in FIG. 4A. For the example illustrated in FIG. 15, the corpus of utterances 112 may be, for example, a collection of chat logs storing utterances user utterances 122 and agent utterances 124 from various chat room exchanges, or other suitable source data.),
Drake and Sapugay are considered to be analogous to the claimed invention because they are in the same field of machine learning. In view of the teachings of Drake, it would have been obvious for a person of ordinary skill in the art to apply the teachings of Sapugay to Drake before the effective filing date of the claimed invention in order to create a virtual agent capable of comprehending complex language and executing contextually relevant requests and to address the hard problem posed by NLU by transforming it into a manageable search problem (cf. Sapugay, [0007] As such, it is presently recognized that there is a need to improve the ability of virtual agents to apply NLU techniques to properly derive meaning from complex natural language utterances. For example, it may be advantageous to create a virtual agent capable of comprehending complex language and executing contextually relevant requests, which could afford substantial advantages in terms of reduced operational cost and increased responsiveness to client issues. Additionally, it is recognized that it is advantageous for virtual agents to be customizable and adaptable to various communication channels and styles.; [0009] Present embodiments are directed to an agent automation framework that is capable of extracting meaning from user utterances, such as requests received by a virtual agent (e.g., a chat agent), and suitably responding to these user utterances. To do this, the agent automation framework includes a NLU framework and an intent/entity model having defined intents and entities that are associated with sample utterances. The NLU framework includes a meaning extraction subsystem that is designed to generate meaning representations for the sample utterances of the intent/entity model, as well as a meaning representation for a received user utterance. Additionally, the disclosed NLU framework includes a meaning search subsystem that is designed to search the meaning representations of the intent/entity model to locate matches for a meaning representation of a received user utterance. As such, present embodiments generally address the hard problem posed by NLU by transforming it into a manageable search problem.).
Rosenbaum teaches generate a synthesized parse tree dataset including synthesized parse trees sampled at random from the trained differentially private parse tree generation model ([3 CLASP Methods] To address the challenge of maintaining text-label agreement when generating SP training data, we propose CLASP (Cross-Lingual data Augmentation for Semantic Parsing). CLASP consists of four methods for prompting LLMs to generate training data, either in the Same Language [SL] or Cross Lingually [CL]: (1) RS: Replace Slots, Generate Text [SL]; (2) TS: Translate Slots, Generate Text [CL]; (3) GB: Generate Both Parse and Text [SL]; and (4) TB: Translate Both Parse and Text [CL].; [3.1 RS: Replace Slots, Generate Text [SL]] As shown in Figure 3 (Appendix A.1), we start with a real training example, ei = (xi,yi) such as with input text xi = “i need to get five small mush room and bacon pizzas with a pepsi”, and target ground-truth parse yi = “(Pizzaorder ... (Topping mushroom ) ... )”. To create a novel training ex ample ei = (xi,yi) we apply a generate a synthesized parse tree dataset including synthesized parse trees sampled at random from the trained differentially private parse tree generation model modification F(·) on the parse yi to obtain yi = F(yi), then prompt a LLM to generate a corresponding text xi. Specifically, F(·) randomly selects one slot (leaf nodes in the parse tree) of yi, and replaces the slot value in the parse with a different value from a catalog. In this instance, we replace the Topping “mushroom” with “spinach”, giving yi = “(Pizza order ... (Topping spinach ) ... )”. To help the model understand how to generate the text xi, we include in the prompt 4 other context examples {cj = (xj,yj)}4 j=1 followed by the original ex ample ej, each verbalized as Semantic Parse: yi Translation in English: xi.); and
Drake, Sapugay, and Rosenbaum are considered to be analogous to the claimed invention because they are in the same field of machine learning. In view of the teachings of Drake and Sapugay, it would have been obvious for a person of ordinary skill in the art to apply the teachings of Rosenbaum to Drake before the effective filing date of the claimed invention in order to improve low-resource SP for moderate-sized models (cf. Rosenbaum, [Abstract] A bottleneck to developing Semantic Parsing (SP) models is the need for a large volume of human-labeled training data. Given the complexity and cost of human annotation for SP, labeled data is often scarce, particularly in multilingual settings. Large Language Models (LLMs) excel at SP given only a few examples, however LLMs are unsuitable for runtime systems which require low latency. In this work, we propose CLASP, a simple method to improve low-resource SP for moderate-sized models: we generate synthetic data from AlexaTM 20B to augment the training set for a model 40x smaller (500M parameters). We evaluate on two datasets in low resource settings: English PIZZA, containing either 348 or 16 real examples, and mTOP cross-lingual zero-shot, where training data is available only in English, and the model must generalize to four new languages. On both datasets, we show significant improvements over strong baseline methods.).
Regarding claim 2 and analogous claims 10, 18, Drake, as modified by Sapugay and Rosenbaum, teaches The computing system of claim 1, The computer-implemented method of claim 9, The computing system of claim 17, respectively.
Sapugay teaches wherein the private parse trees of the private utterance-parse tree dataset are generated by a semantic parser model based at least on the private utterances of the private utterance-parse tree dataset ([0075] For the embodiment illustrated in FIG. 7, the structure subsystem 172 of the meaning extraction subsystem 150 based at least on the private utterances of the private utterance-parse tree dataset analyzes a linguistic shape of the utterance 168 using a combination of rule-based and ML-based structure parsing plugins 184. In other words, the illustrated structure plug-ins 184 enable private parse trees of the private utterance-parse tree dataset are analysis and extraction of the syntactic and grammatical structure of the utterances 122 and 155. For the illustrated embodiment, the structure plug-ins 184 generated by a semantic parser model include rule-based parsers 186, ML-based parsers 188 (e.g., DNN-based parsers, RNN-based parsers, and so forth), and other suitable parser models 190.),
Drake teaches wherein the semantic parser model is trained based at least on public training data ([Col. 11, Lines 41-46] In some embodiments, the differentially private exploration tree is build using a public dataset D containing a list of queries Q. In this context, a “public” dataset may include a publicly-available dataset as well as a dataset that is widely available within an organization, but that is not shared externally.; [Col. 21 Lines 7-13] The remote server 500 may be configured to communicate via one or more networks with one or more servers, search engines, user devices, or the like. In some embodiments, a single remote server or single group of remote servers may be configured to perform product collection generation, product collection surfacing, and/or machine learning functionality.).
Drake, Sapugay, and Rosenbaum are combinable for the same rationale as set forth above with respect to claim 1.
Regarding claim 5 and analogous claim 13, Drake, as modified by Sapugay and Rosenbaum, teaches The computing system of claim 1, The computer-implemented method of claim 11, respectively.
Sapugay teaches wherein the one or more processors are configured to execute instructions stored in the memory to: annotate the synthesized utterances of the synthesized utterance dataset with corresponding expert-generated parse trees to generate an annotated synthesized utterance dataset ([0067] For the embodiment of the agent automation framework 100 illustrated in FIG. 4B, the shared NLU trainer 126 is designed to receive the corpus of utterances 112 from the client instance 42, and to perform semantic mining (e.g., including semantic parsing, grammar engineering, and so forth) to facilitate generation of the intent/entity model 108. Once the intent/entity model 108 has been generated, when the RA/BE 102 receives the user utterance 122 provided by the client device 14D, the NLU predictor 128 passes the utterance 122 and the intent/entity model 108 to the shared NLU annotator 127 for annotate the synthesized utterances of the synthesized utterance dataset parsing and annotation of the utterance 122. The shared NLU annotator 127 performs semantic parsing, grammar engineering, and so forth, of the utterance 122 based on the intent/entity model 108 and returns with corresponding expert-generated parse trees annotated utterance trees of the utterance 122 to the NLU predictor 128 of client instance 42. The NLU predictor 128 then uses these to generate an annotated synthesized utterance dataset annotated structures of the utterance 122, discussed below in greater detail, to identify matching intents from the intent/entity model 108, such that the RA/BE 102 can perform one or more actions based on the identified intents. It may be appreciated that the shared NLU annotator 127 may correspond to the meaning extraction subsystem 150, and the NLU predictor may correspond to the meaning search subsystem 152, of the NLU framework 104, as discussed below.); and
re-train the differentially private parse-to-utterance model based at least on the annotated synthesized utterance dataset ([0084] In certain embodiments, this cycle may repeat any suitable number of times, until errors are no longer detected at decision block 218. At that point, the meaning extraction subsystem 150 generates (block 226) the corresponding meaning representation 212 to be processed by the meaning search subsystem 152, as discussed below. In certain embodiments, information regarding the corrections performed in block 220 and the based at least on the annotated synthesized utterance dataset resulting annotated utterance tree 166 that is converted to the meaning representation 212 may be provided as input to re-train train one or more ML-based plugins of the meaning extraction subsystem 150 e.g., ML-based parsers 188 or ML-based prosody systems 196), such that the erroneous annotated utterance trees can be avoided when processing future utterances.).
Drake, Sapugay, and Rosenbaum are combinable for the same rationale as set forth above with respect to claim 1.
Regarding claim 17, Drake teaches A computing system comprising: one or more processors configured to execute instructions stored in memory to ([Col. 14, Line 58-Col. 15, Line 2] To provide privacy and intent-preserving redactions, an example process flow 150 is presented and may be performed, for example, by the utterance detection module 106, the redaction module 110, and/or the redaction delivery module 124. In some embodiments, the utterance detection module 106, the redaction module 110, and/or the redaction delivery module 124 may each include at least one memory that stores computer-executable instructions and at least one processor configured to access the at least one memory and execute the computer-executable instructions to perform various actions or operations, such as one or more of the operations in the process flow 150 of FIG. 1.):
train a differentially private parse tree generation model ([Col. 11, Lines 41-46] In some embodiments, the differentially private exploration tree is build using a public dataset D containing a list of queries Q. In this context, a “public” dataset may include a publicly-available dataset as well as a dataset that is widely available within an organization, but that is not shared externally.; [Col. 21 Lines 7-13] The remote server 500 may be configured to communicate via one or more networks with one or more servers, search engines, user devices, or the like. In some embodiments, a single remote server or single group of remote servers may be configured to perform product collection generation, product collection surfacing, and/or machine learning functionality.)
train a differentially private parse-to-utterance model ([Col. 11, Lines 41-46] In some embodiments, the differentially private exploration tree is build using a public dataset D containing a list of queries Q. In this context, a “public” dataset may include a publicly-available dataset as well as a dataset that is widely available within an organization, but that is not shared externally.; [Col. 21 Lines 7-13] The remote server 500 may be configured to communicate via one or more networks with one or more servers, search engines, user devices, or the like. In some embodiments, a single remote server or single group of remote servers may be configured to perform product collection generation, product collection surfacing, and/or machine learning functionality.)
Drake fails to teach based at least on private parse trees of a private utterance-parse tree dataset; train a differentially private parse tree generation model, train a differentially private parse-to-utterance model based at least on private utterances and corresponding private parse trees of the private utterance-parse tree dataset; generate a synthesized parse tree dataset including synthesized parse trees sampled at random from the trained differentially private parse tree generation model; and generate, a synthesized utterance dataset including synthesized utterances based at least on the synthesized parse trees of the synthesized parse tree dataset, via the trained differentially private parse-to-utterance model, annotate the synthesized utterances of the synthesized utterance dataset with corresponding expert-generated parse trees; and re-train the differentially private parse-to-utterance model based at least on the annotated synthesized utterance dataset
Sapugay teaches based at least on private parse trees of a private utterance-parse tree dataset ([0114] The NLU framework includes a meaning extraction subsystem that is designed to generate meaning representations for the sample utterances of the intent/entity model, as well as a meaning representation for a received user utterance. To generate these meaning representations, the meaning extraction subsystem includes a vocabulary subsystem, a structure subsystem, and a prosody subsystem that cooperate to parse utterances based on combinations of rule-based methods and ML-based methods. Further, for improved accuracy, the meaning extraction subsystem includes a rule-based augmentation error detection subsystem that can cooperate with the vocabulary, structure subsystem, and prosody subsystems to iteratively parse and correct an utterance before meaning representations are generated. The of a private utterance-parse tree dataset meaning representations are a data structure having a form or shape that captures the grammatical structure of the utterance, while based at least on private parse trees subtrees of the data structure capture the semantic meaning of the words and phases of the utterance as vectors that are annotated with additional information (e.g., class information).);
train a differentially private parse tree generation model ([0072] The parse tree generation model meaning extraction subsystem of FIG. 6 itself includes a number of subsystems that cooperate to generate the meaning representations 158 and 162.; [0108] For the example illustrated in FIG. 14, when the meaning extraction subsystem 150 determines in block 328 that a sufficient number (e.g., a majority, greater than a predetermined threshold value) of annotated utterance trees 326 for a particular utterance are substantially the same for a quorum to be reached, then the meaning extraction subsystem 150 may use the quorum-based set of annotated utterance trees 330 to train train and improve a ML-model 322 associated with the ML-based parser 188, as indicated by the arrow 331.)
train a differentially private parse-to-utterance model based at least on private utterances and corresponding private parse trees of the private utterance-parse tree dataset ([0094] Once the meaning representations 158 and 162 have been generated, as illustrated in FIG. 5, the meaning search subsystem 152 can compare these meaning representations to extract intent/entities from the user utterance 122. FIG. 12 is a flow diagram illustrating an example embodiment of a process 280 whereby the parse-to-utterance model meaning search subsystem 152 searches the based at least on private utterances and corresponding private parse trees of the private utterance-parse tree dataset meaning representations 158 of the understanding model 157 for matches to the meaning representation 162 of the user utterance 122 based on information stored in the compilation model template 244. For the embodiment illustrated in FIG. 12, the meaning search subsystem 152 receives the at least one meaning representation 162 of the utterance meaning model 160 generated in FIG. 9, as discussed above. Using the prosody subsystem 174 discussed above, the meaning search subsystem 152 first segments (block 282) the meaning representations 162 into intent subtrees, each representing an atomic intent, based on one or more stored rules 114 (e.g., intent-segmentation rules).; As such, it is appreciated that, by expanding or modifying the word vector distribution model 342, operation of the vocabulary subsystem 170, the NLU framework 104, and the agent automation system 100 can be train improved to handle words with new or changing meanings using only training data that can be generated from a continually growing corpus of utterances 112 of the database 106 illustrated in FIG. 4A. For the example illustrated in FIG. 15, the corpus of utterances 112 may be, for example, a collection of chat logs storing utterances user utterances 122 and agent utterances 124 from various chat room exchanges, or other suitable source data.);
generate, a synthesized utterance dataset including synthesized utterances based at least on the synthesized parse trees of the synthesized parse tree dataset ([0070] The meaning extraction subsystem 150 generates an understanding model 157 that includes meaning representations 158 of the sample utterances 155 of the intent/entity model 108. In other words, the understanding model 157 is a translated or augmented version of the intent/entity model 108 that includes meaning representations 158 to enable searching (e.g., comparison and matching) by the meaning search subsystem 152, as discussed below. As such, it may be appreciated that the right-hand portion 154 of FIG. 6 is generally performed in advance of receiving the user utterance 122, such as on a routine, scheduled basis or in response to updates to the intent/entity model 108.; [0082] For the embodiment illustrated in FIG. 8, the process 210 begins with the meaning extraction subsystem 150 of the NLU framework 104 generating (block 214) the generate, a synthesized utterance dataset including synthesized utterances based at least on the synthesized parse trees of the synthesized parse tree dataset annotated utterance tree 166 from the utterance 168 using one or more ML-based plugins (e.g., ML-based parsers 188 or ML-based prosody systems 196), as discussed above. In certain embodiments, this step may include a preliminary cleansing and augmentation step performed before the annotated utterance tree 166 is generated. For example, in certain embodiments, this preliminary cleansing and augmentation step may involve the vocabulary subsystem 170, the structure subsystem 172, and/or the prosody subsystem 174 modifying the utterance 168 based on the stored rules 114.).
via the trained differentially private parse-to-utterance model ([0094] Once the meaning representations 158 and 162 have been generated, as illustrated in FIG. 5, the meaning search subsystem 152 can compare these meaning representations to extract intent/entities from the user utterance 122. FIG. 12 is a flow diagram illustrating an example embodiment of a process 280 whereby the parse-to-utterance model meaning search subsystem 152 searches the meaning representations 158 of the understanding model 157 for matches to the meaning representation 162 of the user utterance 122 based on information stored in the compilation model template 244. For the embodiment illustrated in FIG. 12, the meaning search subsystem 152 receives the at least one meaning representation 162 of the utterance meaning model 160 generated in FIG. 9, as discussed above. Using the prosody subsystem 174 discussed above, the meaning search subsystem 152 first segments (block 282) the meaning representations 162 into intent subtrees, each representing an atomic intent, based on one or more stored rules 114 (e.g., intent-segmentation rules).; As such, it is appreciated that, by expanding or modifying the word vector distribution model 342, operation of the vocabulary subsystem 170, the NLU framework 104, and the agent automation system 100 can be trained improved to handle words with new or changing meanings using only training data that can be generated from a continually growing corpus of utterances 112 of the database 106 illustrated in FIG. 4A. For the example illustrated in FIG. 15, the corpus of utterances 112 may be, for example, a collection of chat logs storing utterances user utterances 122 and agent utterances 124 from various chat room exchanges, or other suitable source data.),
annotate the synthesized utterances of the synthesized utterance dataset with corresponding expert-generated parse trees ([0067] For the embodiment of the agent automation framework 100 illustrated in FIG. 4B, the shared NLU trainer 126 is designed to receive the corpus of utterances 112 from the client instance 42, and to perform semantic mining (e.g., including semantic parsing, grammar engineering, and so forth) to facilitate generation of the intent/entity model 108. Once the intent/entity model 108 has been generated, when the RA/BE 102 receives the user utterance 122 provided by the client device 14D, the NLU predictor 128 passes the utterance 122 and the intent/entity model 108 to the shared NLU annotator 127 for annotate the synthesized utterances of the synthesized utterance dataset parsing and annotation of the utterance 122. The shared NLU annotator 127 performs semantic parsing, grammar engineering, and so forth, of the utterance 122 based on the intent/entity model 108 and returns with corresponding expert-generated parse trees annotated utterance trees of the utterance 122 to the NLU predictor 128 of client instance 42. The NLU predictor 128 then uses these annotated structures of the utterance 122, discussed below in greater detail, to identify matching intents from the intent/entity model 108, such that the RA/BE 102 can perform one or more actions based on the identified intents. It may be appreciated that the shared NLU annotator 127 may correspond to the meaning extraction subsystem 150, and the NLU predictor may correspond to the meaning search subsystem 152, of the NLU framework 104, as discussed below.); and
re-train the differentially private parse-to-utterance model based at least on the annotated synthesized utterance dataset ([0084] In certain embodiments, this cycle may repeat any suitable number of times, until errors are no longer detected at decision block 218. At that point, the meaning extraction subsystem 150 generates (block 226) the corresponding meaning representation 212 to be processed by the meaning search subsystem 152, as discussed below. In certain embodiments, information regarding the corrections performed in block 220 and the based at least on the annotated synthesized utterance dataset resulting annotated utterance tree 166 that is converted to the meaning representation 212 may be provided as input to re-train train one or more ML-based plugins of the meaning extraction subsystem 150 e.g., ML-based parsers 188 or ML-based prosody systems 196), such that the erroneous annotated utterance trees can be avoided when processing future utterances.).
Drake and Sapugay are combinable for the same rationale as set forth above with respect to claim 1.
Rosenbaum teaches generate a synthesized parse tree dataset including synthesized parse trees sampled at random from the trained differentially private parse tree generation model ([3 CLASP Methods] To address the challenge of maintaining text-label agreement when generating SP training data, we propose CLASP (Cross-Lingual data Augmentation for Semantic Parsing). CLASP consists of four methods for prompting LLMs to generate training data, either in the Same Language [SL] or Cross Lingually [CL]: (1) RS: Replace Slots, Generate Text [SL]; (2) TS: Translate Slots, Generate Text [CL]; (3) GB: Generate Both Parse and Text [SL]; and (4) TB: Translate Both Parse and Text [CL].; [3.1 RS: Replace Slots, Generate Text [SL]] As shown in Figure 3 (Appendix A.1), we start with a real training example, ei = (xi,yi) such as with input text xi = “i need to get five small mush room and bacon pizzas with a pepsi”, and target ground-truth parse yi = “(Pizzaorder ... (Topping mushroom ) ... )”. To create a novel training ex ample ei = (xi,yi) we apply a generate a synthesized parse tree dataset including synthesized parse trees sampled at random from the trained differentially private parse tree generation model modification F(·) on the parse yi to obtain yi = F(yi), then prompt a LLM to generate a corresponding text xi. Specifically, F(·) randomly selects one slot (leaf nodes in the parse tree) of yi, and replaces the slot value in the parse with a different value from a catalog. In this instance, we replace the Topping “mushroom” with “spinach”, giving yi = “(Pizza order ... (Topping spinach ) ... )”. To help the model understand how to generate the text xi, we include in the prompt 4 other context examples {cj = (xj,yj)}4 j=1 followed by the original ex ample ej, each verbalized as Semantic Parse: yi Translation in English: xi.); and
Drake, Sapugay, and Rosenbaum are combinable for the same rationale as set forth above with respect to claim 1.
Claims 3, 7, 11, 15, 19 are rejected under 35 U.S.C. 103 as being unpatentable over Drake, in view of Sapugay, Rosenbaum, and further in view of Li et al. (NPL: "LARGE LANGUAGE MODELS CAN BE STRONG DIFFERENTIALLY PRIVATE LEARNERS", hereinafter 'Li').
Regarding claim 3 and analogous claims 11, 19, Drake, as modified by Sapugay and Rosenbaum, teaches The computing system of claim 1, The computer-implemented method of claim 9, The computing system of claim 17, respectively.
Drake, as modified by Sapugay and Rosenbaum, fails to teach wherein the differentially private parse tree generation model and the differentially private parse-to-utterance model are trained using a differentially private stochastic gradient descent (DP-SGD) training algorithm.
Li teaches wherein the differentially private parse tree generation model and the differentially private parse-to-utterance model are trained using a differentially private stochastic gradient descent (DP-SGD) training algorithm ([ 1 Introduction, pg. 2] (1) We show that with appropriate hyperparameters and downstream task objectives, wherein the differentially private parse tree generation model and the differentially private parse-to-utterance model are trained using a differentially private stochastic gradient descent (DP-SGD) training algorithm directly fine tuning pretrained language models with DP-SGD yields strong performance for a suite of NLP tasks at privacy levels ∈ {3,8}. Notably, some of our fine-tuned models outperform strong non-private learning baselines and models obtained under heuristic privacy notions. (2) DP-SGD is known for its expensive memory cost due to clipping per-example gradients. We present ghost clipping, a memory saving technique that makes fine-tuning larger Transformers under DP computationally efficient. Our technique generalizes the Goodfellow (2015) trick to handle sequential inputs, and can be combined with a layer-by-layer clipping procedure (Lee & Kifer, 2020) to enable privately fitting large Transformers with almost the same memory storage as non-private training—at the cost of one additional backward pass per processed batch.).
Drake, Sapugay, Rosenbaum, and Li are considered to be analogous to the claimed invention because they are in the same field of machine learning. In view of the teachings of Drake, Sapugay, and Rosenbaum, it would have been obvious for a person of ordinary skill in the art to apply the teachings of Li to Drake before the effective filing date of the claimed invention in order to obtain private NLP models that outperform state-of-the-art private training approaches and strong non private baselines—by directly fine-tuning pretrained models with DP optimization on moderately-sized corpora (cf. Li, [Abstract, pg. 1] Differentially Private (DP) learning has seen limited success for building large deep learning models of text, and attempts at straightforwardly applying Differentially Private Stochastic Gradient Descent (DP-SGD) to NLP tasks have resulted in large performance drops and high computational overhead. We show that this performance drop can be mitigated with (1) the use of large pretrained models; (2) hyperparameters that suit DP optimization; and (3) fine-tuning objectives aligned with the pretraining procedure. With these factors set right, we obtain private NLP models that outperform state-of-the-art private training approaches and strong non private baselines—by directly fine-tuning pretrained models with DP optimization on moderately-sized corpora. To address the computational challenge of running DP-SGD with large Transformers, we propose a memory saving technique that allows clipping in DP-SGD to run without instantiating per-example gradients for any layer in the model. The technique enables privately training Transformers with almost the same memory cost as non-private training at a modest run-time overhead. Contrary to conventional wisdom that DP optimization fails at learning high-dimensional models (due to noise that scales with dimension) empirical results reveal that private learning with pretrained models tends to not suffer from dimension-dependent performance degradation.).
Regarding claim 7 and analogous claim 15, Drake, as modified by Sapugay and Rosenbaum, teaches The computing system of claim 1, The computer-implemented method of claim 9, respectively.
Drake, as modified by Sapugay and Rosenbaum, fails to teach wherein the differentially private parse tree generation model and the differentially private parse-to-utterance model are trained using a same noise multiplier parameter value and a same clipping threshold parameter value.
Li teaches wherein the differentially private parse tree generation model and the differentially private parse-to-utterance model are trained using a same noise multiplier parameter value and a same clipping threshold parameter value ([2 PROBLEM STATEMENT, pg. 3] DP models are typically trained with DP optimizers which privatize the gradient before taking a standard gradient descent step. The privatization step ensures that the parameter updates leak limited information about the training examples through their gradients. Specifically, this step and a same clipping threshold parameter value clips per example gradients with a norm constraint C, and adds isotropic Gaussian noise z ∼ N(0,C2σ2Ip) to the sum of clipped gradients. Here, wherein the differentially private parse tree generation model and the differentially private parse-to-utterance model are trained using a same noise multiplier parameter value σ is the noise multiplier determined from the privacy budget ( , δ), number of gradient updates S, and sampling rate q = B N for a batch size of B and a dataset with N examples. Intuitively, clipping individual gradients ensures that each example has bounded influence on the parameter update, whereas noising the gradient denies exact tracing of particular examples.).
Drake, Sapugay, Rosenbaum, and Li are combinable for the same rationale as set forth above with respect to claim 3.
Claims 4, 12, 20 are rejected under 35 U.S.C. 103 as being unpatentable over Drake, in view of Sapugay, Rosenbaum, Li, and further in view of Galitsky et al. (U.S. Pre-Grant Publication No. 20190095425, hereinafter 'Galitsky') and Kerrigan et al. (NPL: "Differentially Private Language Models Benefit from Public Pre-training", hereinafter 'Kerrigan').
Regarding claim 4 and analogous claims 12, 20, Drake, as modified by Sapugay, Rosenbaum, and Li, teaches The computing system of claim 3, The computer-implemented method of claim 11, The computing system of claim 19, respectively.
Li teaches wherein training the differentially private parse tree generation model includes fine-tuning a pre-trained language model based at least on the parse trees of the private utterance-parse tree dataset using the DP-SGD training algorithm ([1 Introduction, pg. 2] (1) We show that with appropriate hyperparameters and downstream task objectives, directly fine-tuning a pre-trained language model fine tuning pretrained language models using the DP-SGD training algorithm with DP-SGD yields strong performance for a suite of NLP tasks at privacy levels ∈ {3,8}. Notably, some of our fine-tuned models outperform strong non-private learning baselines and models obtained under heuristic privacy notions.),
wherein training the differentially private parse-to-utterance model includes fine-tuning a pre-trained parse-to-utterance model based at least on the private user utterances and the parse trees of the private utterance-parse tree dataset using the DP-SGD training algorithm ([1 Introduction, pg. 1] We tackle the problem of building performant wherein training the differentially private DP language models for sentence classification and language generation tasks with tens to hundreds of thousands of examples. We pursue this goal by reexamining the performance of the baseline DP optimization algorithm for fine-tuning large language models, and study how choices of hyperparameters, training objective, and pretrained models affect the performance of models given fixed privacy budgets. In contrast to the mainstream perception, our empirical results demonstrate that large pretrained models with hundreds of millions of parameters can be effectively and efficiently fine-tuned to yield models with high performance with modest privacy leakage.; [1 Introduction, pg. 2] (1) We show that with appropriate hyperparameters and downstream task objectives, directly includes fine-tuning a pre-trained fine tuning pretrained language models using the DP-SGD training algorithm with DP-SGD yields strong performance for a suite of NLP tasks at privacy levels ∈ {3,8}. Notably, some of our fine-tuned models outperform strong non-private learning baselines and models obtained under heuristic privacy notions.), and
Drake, as modified by Sapugay, Rosenbaum, and Li, fails to teach fine-tuning a pre-trained language model based at least on the parse trees of the private utterance-parse tree dataset using the DP-SGD training algorithm, wherein the pre-trained language model is trained using public training data, wherein training the differentially private parse-to-utterance model includes fine-tuning a pre-trained parse-to-utterance model based at least on the private user utterances and the parse trees of the private utterance-parse tree dataset using the DP-SGD training algorithm, and wherein the pre-trained parse-to-utterance model is trained using public training data; wherein the pre-trained parse-to-utterance model is trained using public training data
Galitsky teaches fine-tuning a pre-trained language model based at least on the parse trees of the private utterance-parse tree dataset using the DP-SGD training algorithm ([0052] FIG. 2 depicts an example of a parse tree, in accordance with an aspect. FIG. 2 depicts parse tree 200, which parser 131 generates from the sentence “Turn on the light.” Parse tree 200 includes nodes 201-204. Each node is indicated by a type, which can in turn be further refined by additional analysis. Table 1 describes examples of types, but others are possible. As can be seen in FIG. 2, parser 131 determines verb phrase “turn” as depicted by node 201, phrasal verb article “on” at node 202, “the” at node 203 and “light” at node 204. They are linked with different relationships such as “dobj” and “det.” Standard parsers can be used such as the Stanford NLP parser.; [0087] FIG. 6 depicts a flowchart illustrating an example of a process for training a classification model to determine informative text for indexing, in accordance with an aspect. As further described in process 600, classification model 150 can be trained to discriminate between questions and requests. Training data 160 can include two training sets, such as a training set with text identified as requests and a second training set with text identified as questions. based at least on the parse trees of the private utterance-parse tree dataset Training data 160 can include text and/or associated parse trees.),
wherein training the differentially private parse-to-utterance model includes fine-tuning a pre-trained parse-to-utterance model based at least on the private user utterances and the parse trees of the private utterance-parse tree dataset using the DP-SGD training algorithm ([0052] FIG. 2 depicts an example of a parse tree, in accordance with an aspect. FIG. 2 depicts parse tree 200, which parser 131 generates from the sentence “Turn on the light.” Parse tree 200 includes nodes 201-204. Each node is indicated by a type, which can in turn be further refined by additional analysis. Table 1 describes examples of types, but others are possible. As can be seen in FIG. 2, parser 131 determines verb phrase “turn” as depicted by node 201, phrasal verb article “on” at node 202, “the” at node 203 and “light” at node 204. They are linked with different relationships such as “dobj” and “det.” Standard parsers can be used such as the Stanford NLP parser.; [0087] FIG. 6 depicts a flowchart illustrating an example of a process for parse-to-utterance model training a classification model to determine informative text for indexing, in accordance with an aspect. As further described in process 600, classification model 150 can be trained to discriminate between questions and requests. Training data 160 can include two training sets, such as a training set with text identified as requests and a second training set with text identified as questions. parse-to-utterance model based at least on the private user utterances and the parse trees of the private utterance-parse tree dataset Training data 160 can include text and/or associated parse trees.), and
wherein the pre-trained parse-to-utterance model is trained using public training data ([0052] FIG. 2 depicts an example of a parse tree, in accordance with an aspect. FIG. 2 depicts parse tree 200, which parser 131 generates from the sentence “Turn on the light.” Parse tree 200 includes nodes 201-204. Each node is indicated by a type, which can in turn be further refined by additional analysis. Table 1 describes examples of types, but others are possible. As can be seen in FIG. 2, parser 131 determines verb phrase “turn” as depicted by node 201, phrasal verb article “on” at node 202, “the” at node 203 and “light” at node 204. They are linked with different relationships such as “dobj” and “det.” Standard parsers can be used such as the Stanford NLP parser.; [0087] FIG. 6 depicts a flowchart illustrating an example of a process for parse-to-utterance model training a classification model to determine informative text for indexing, in accordance with an aspect. As further described in process 600, classification model 150 can be trained to discriminate between questions and requests. Training data 160 can include two training sets, such as a training set with text identified as requests and a second training set with text identified as questions. Training data 160 can include text and/or associated parse trees.);
Drake, Sapugay, Rosenbaum, Li, and Galitsky are considered to be analogous to the claimed invention because they are in the same field of machine learning. In view of the teachings of Drake, Sapugay, Rosenbaum, and Li, it would have been obvious for a person of ordinary skill in the art to apply the teachings of Galitsky to Drake before the effective filing date of the claimed invention in order to provide technical improvements to the area of computer-implemented linguistics by providing improved classification of text (cf. Galitsky, [0029] Aspects disclosed herein provide technical improvements to the area of computer-implemented linguistics by providing improved classification of text. More specifically, certain aspects use linguistics to determine whether text is a question or a request for an action to be performed. As discussed above, existing solutions for autonomous agents are unable to discriminate between a question and a transactional request, leading to a failed interaction between agent and user.).
Kerrigan teaches wherein the pre-trained language model is trained using public training data ([1 Introduction, pg. 39] We instead is trained using public training data train a non-private base model on a large, public dataset, which we proceed to fine tune on a private out-of-distribution dataset through differentially private stochastic gradient descent (DPSGD) (Abadi et al., 2016). By doing so, we successfully train a high-quality model which is differentially private with respect to our tuning dataset. Our experimental results show that DP fine-tuning not only boosts the performance of DP language modeling, but makes it possible.; [2 Related Work, pg. 40] In contrast, our work begins with a wherein the pre-trained language model pre-trained model which only has access to publicly available data. This base model is then fine-tuned through DPSGD on our private domain of interest, resulting in a model that is both differentially private and tuned with respect to our protected dataset. By tuning a pre-trained public model, we achieve higher quality models without incurring any additional costs to our privacy budget.),
wherein the pre-trained parse-to-utterance model is trained using public training data ([1 Introduction, pg. 39] We instead is trained using public training data train a non-private base model on a large, public dataset, which we proceed to fine tune on a private out-of-distribution dataset through differentially private stochastic gradient descent (DPSGD) (Abadi et al., 2016). By doing so, we successfully train a high-quality model which is differentially private with respect to our tuning dataset. Our experimental results show that DP fine-tuning not only boosts the performance of DP language modeling, but makes it possible.; [2 Related Work, pg. 40] In contrast, our work begins with a wherein the pre-trained pre-trained model which only has access to publicly available data. This base model is then fine-tuned through DPSGD on our private domain of interest, resulting in a model that is both differentially private and tuned with respect to our protected dataset. By tuning a pre-trained public model, we achieve higher quality models without incurring any additional costs to our privacy budget.).
Drake, Sapugay, Rosenbaum, Li, Galitsky, and Kerrigan are considered to be analogous to the claimed invention because they are in the same field of machine learning. In view of the teachings of Drake, Sapugay, Rosenbaum, Li, and Galitsky, it would have been obvious for a person of ordinary skill in the art to apply the teachings of Kerrigan to Drake before the effective filing date of the claimed invention in order to DP fine-tune, boosting the performance of language models in the private domain (cf. Kerrigan, [Abstract, pg. 39] Language modeling is a keystone task in natural language processing. When training a language model on sensitive information, differential privacy (DP) allows us to quantify the degree to which our private data is protected. However, training algorithms which enforce differential privacy often lead to degradation in model quality. We study the feasibility of learning a language model which is simultaneously high-quality and privacy preserving by tuning a public base model on a private corpus. We find that DP fine-tuning boosts the performance of language models in the private domain, making the training of such models possible.).
Claims 6, 14 are rejected under 35 U.S.C. 103 as being unpatentable over Drake, in view of Sapugay, Rosenbaum, and further in view of Jiang et al. (NPL: "DP2-VAE: Differentially Private Pre-trained Variational Autoencoders", hereinafter 'Jiang').
Regarding claim 6 and analogous claim 14, Drake, as modified by Sapugay and Rosenbaum, teaches The computing system of claim 1, The computer-implemented method of claim 9, respectively.
Drake, as modified by Sapugay and Rosenbaum, fails to teach wherein the differentially private parse tree generation model and the differentially private parse-to-utterance model are trained independent of one another and in parallel.
Jiang teaches wherein the differentially private parse tree generation model and the differentially private parse-to-utterance model are trained independent of one another and in parallel ([3.1 Stage 1: Pre-training encoders on private input, pg. 4] Stage 1 is similar to normally training a conditional VAE with gradient clipping. Differently, we partition the dataset into subsets, and each encoder is pre-trained on a subset with a reinitialized decoder. The detailed algorithm is given in Algorithm 1. The weights of pre-trained encoder in stage 1 will be transferred as input to stage 2. Note that encoders are independent of each other, so the pre-training can be conducted in parallel.; [3.2 Stage 2: Privately training the decoder with pre-trained encoder, pg. 4] In stage 2, we load pre-trained encoders Tθk (k = 1,2,...,K) obtained in stage 1. In each training iteration, we randomly query one encoder and its associated training subset, then update decoder and encoder on the subset by private and non-private training algorithms, respectively, as described in Algorithm 2. We note that an alternative to stage 2 is to fix the pre-trained encoder. However, we empirically found that keep training the pre-trained encoder outperforms the aforementioned alternative, thus we adopt the strategy as described in this subsection in our work.).
Drake, Sapugay, Rosenbaum, and Jiang are considered to be analogous to the claimed invention because they are in the same field of machine learning. In view of the teachings of Drake, Sapugay, and Rosenbaum, it would have been obvious for a person of ordinary skill in the art to apply the teachings of Jiang to Drake before the effective filing date of the claimed invention in order to minimize the perturbation noise during training, and hence improves utility (cf. Jiang, [Abstract, pg. 1] Modern machine learning systems achieve great success when trained on large datasets. However, these datasets usually contain sensitive information (e.g. medical records, face images), leading to serious privacy concerns. Differentially private generative models (DPGMs) emerge as a solution to circumvent such privacy concerns by generating privatized sensitive data. Similar to other differentially private (DP) learners, the major challenge for DPGM is also on how to achieve a subtle balance between utility and privacy. We propose DP2-VAE, a novel training mechanism for variational autoencoders (VAE) with provable DP guarantees and improved utility via pre-training on private data. Under the same DP constraints, DP2-VAE minimizes the perturbation noise during training, and hence improves utility. DP2-VAE is very flexible and easily amenable to many other VAE variants. Theoretically, we study the effect of pretraining on private data. Empirically, we conduct extensive experiments on image datasets to illustrate our superiority over baselines under various privacy budgets and evaluation metrics.).
Claims 8, 16 are rejected under 35 U.S.C. 103 as being unpatentable over Drake, in view of Sapugay, Rosenbaum, and further in view of Galitsky.
Regarding claim 8 and analogous claim 16, Drake, as modified by Sapugay and Rosenbaum, teaches The computing system of claim 1, The computer-implemented method of claim 9, respectively.
Drakes teaches wherein a task-oriented natural language dialogue model is trained based at least on the synthesized utterance dataset ([Col. 6, Lines 47-57] Consider a wherein a task-oriented natural language dialogue model natural language sentence x produced by a user interacting with an information system. For example, x might represent a search query, a voice command issued to a virtual assistant, part of a dialogue with an AI agent, etc. In particular, x will contain semantic information about the intent the user is trying to convey, but it might also contain private information like passwords, shipping addresses, phone numbers, and other types of personally identifiable information. It is desirable to produce a redacted version {circumflex over (x)} of x that preserves the original intent while removing any private information.; [Col. 5, Lines 15-24] In some embodiments, the redaction module 110 may trained based at least on the synthesized utterance dataset generate redacted utterance data 112 using a metric differential privacy-compliant redaction algorithm. In some embodiments, the redaction module 110 may receive or generate a text transcription 114 based on the utterance 104 according to one or more embodiments. As depicted in FIG. 1, for example, the text transcription 114 may state, “My password is four three three two.”),
Drake, as modified by Sapugay and Rosenbaum, fails to teach wherein a task-oriented natural language dialogue application generates a dialogue including actual user utterances and responses to the actual user utterances generated via the trained task-oriented natural language dialogue model.
Galitsky teaches wherein a task-oriented natural language dialogue application generates a dialogue including actual user utterances and responses to the actual user utterances generated via the trained task-oriented natural language dialogue model ([0032] Natural language processing (NLP) and machine learning (ML) algorithms combined with other approaches can be used to classify end user intent. An intent at a high level is what the end user would like to accomplish (e.g., get account balance, make a purchase). An intent can be a mapping of customer input to a unit of work that the backend should perform. Intent can also be a class of utterances leading to a specific agent action (e.g., a request). Therefore, based on the phrases uttered by the user in the agent, these are mapped that to a specific and discrete use case or unit of work, for e.g. check balance, transfer money and track spending are all “use cases” that the agent should support and be able to work out which unit of work should be triggered from the free text entry that the end user types in a natural language.; [0050] In an example, user device 170 wherein a task-oriented natural language dialogue application generates a dialogue communicates with autonomous agent 101 to facilitate user questions and requests. Classification application 102 receives message 181 from user device 170. Message 181 is a including actual user utterances user utterance that reads “Transfer funds from checking to savings.” Continuing the example, classification application 102 determines a presence of a leading imperative verb “transfer” and determines that message 181 is a request. Autonomous and responses to the actual user utterances generated via the trained task-oriented natural language dialogue model agent 102 prompts the user to “please confirm the amount” by sending message 182 to user device 170. Subsequently, user device 170 sends a follow-on message 183 that reads “how do I check my balance?” to autonomous agent 101. In turn, classification application 102 determines the user's intent, specifically, a desire for information, and sends back message 184 aiding the user in checking his balance.).
Drake, Sapugay, Rosenbaum, and Galitsky are considered to be analogous to the claimed invention because they are in the same field of machine learning. In view of the teachings of Drake, Sapugay, and Rosenbaum, it would have been obvious for a person of ordinary skill in the art to apply the teachings of Galitsky to Drake before the effective filing date of the claimed invention in order to provide technical improvements to the area of computer-implemented linguistics by providing improved classification of text (cf. Galitsky, [0029] Aspects disclosed herein provide technical improvements to the area of computer-implemented linguistics by providing improved classification of text. More specifically, certain aspects use linguistics to determine whether text is a question or a request for an action to be performed. As discussed above, existing solutions for autonomous agents are unable to discriminate between a question and a transactional request, leading to a failed interaction between agent and user.).
Conclusion
Any inquiry concerning this communication or earlier communications from the examiner should be directed to MAGGIE MAIDO whose telephone number is (703) 756-1953. The examiner can normally be reached M-Th: 6am - 4pm.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Michael Huntley can be reached on (303) 297-4307. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/MM/Examiner, Art Unit 2129
/MICHAEL J HUNTLEY/Supervisory Patent Examiner, Art Unit 2129
Prosecution Insights