Patent Publication Number: US-2021174028-A1

Title: Dialogue state tracking using a global-local encoder

Description:
RELATED APPLICATIONS 
     This application claims the benefit of the U.S. patent application Ser. No. 15/978,445, filed on May 14, 2018, which claims the benefit of the U.S. Provisional Patent Application No. 62/634,130, filed Feb. 22, 2018 and entitled “Dialogue State Tracking Using A Neural Network Model”, which is incorporated by reference in its entirety. 
    
    
     TECHNICAL FIELD 
     Embodiments of the present disclosure relate generally to dialogue state tracking and more particularly to dialogue state tracking using a global-local encoder. 
     BACKGROUND 
     Neural networks have demonstrated great promise as a technique for automatically analyzing real-world information with human-like accuracy. In general, neural network models receive input information and make predictions based on the input information. For example, a neural network classifier may predict a class of the input information among a predetermined set of classes. Whereas other approaches to analyzing real-world information may involve hard-coded processes, statistical analysis, and/or the like, neural networks learn to make predictions gradually, by a process of trial and error, using a machine learning process. A given neural network model may be trained using a large number of training examples, proceeding iteratively until the neural network model begins to consistently make similar inferences from the training examples that a human might make. Neural network models have been shown to outperform and/or have the potential to outperform other computing techniques in a number of applications. Indeed, some applications have even been identified in which neural networking models exceed human-level performance. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1A  is a simplified diagram of a digital system with dialogue state tracking according to some embodiments. 
         FIG. 1B  is a simplified diagram of an example dialogue between a user and the digital system according to some embodiments. 
         FIGS. 2A-2C  are simplified diagrams of a scoring model according to some embodiments. 
         FIG. 3  is a simplified diagram of an encoder according to some embodiments. 
         FIG. 4  is a simplified diagram of a global-local encoder according to some embodiments. 
         FIG. 5  is a simplified diagram of a training configuration for a neural network model according to some embodiments. 
         FIG. 6  is a simplified diagram of a method for maintaining a dialogue state associated with a dialogue between a user and a digital system according to some embodiments. 
         FIG. 7  is a simplified diagram of a method for training a neural network model according to some embodiments. 
         FIGS. 8A and 8B  are simplified diagrams of an experimental evaluation of a dialogue state tracker according to some embodiments. 
     
    
    
     DETAILED DESCRIPTION 
     Dialogue state tracking is one class of problems to which neural networks may be applied. In dialogue state tracking applications, a user engages in a dialogue with an interactive digital system, such as a digital assistant, chatbot, a task-oriented dialogue system (e.g., a restaurant reservation system), and/or the like. To keep track of various objectives expressed by the user and/or responsive actions taken by the digital system over the course of the dialogue, the digital system includes or is associated with a dialogue state tracker that maintains a dialogue state associated with the dialogue. In particular, the dialogue state tracker may include a neural network model for updating the dialogue state at each exchange of the dialogue. For example, suppose a user asks the digital system “Find me a good restaurant on the south side of town.” Suppose further that the digital system replies “Cheap or expensive?” to which the user replies “Cheap. Can you give me the phone number?” In this scenario, the dialogue state tracker should maintain a comprehensive representation of the dialogue state that is cumulative of the dialogue up to that point (e.g., the user has requested a phone number of a restaurant that is cheap and on the south side of town). 
     The performance of dialogue state trackers may be compared or benchmarked by testing different models on a shared dataset, such as, for example, a dataset from the Dialogue System Technology Challenges (DSTC) series of shared tasks. Illustrative examples of tasks that adhere to the DTSC framework include the Wizard of Oz (WoZ) restaurant reservation task and the DSTC2 task. The accuracy of each model may be measured by evaluating one or more metrics, such as cumulative goal accuracy (e.g., the percentage of user goals correctly identified, determined cumulatively over the exchanges in a dialogue), turn request accuracy (the percentage of user requests correctly identified in a given exchanges of the dialogue), and/or the like. State of art dialogue state trackers achieve less than or equal to 73.4% cumulative goal accuracy and less than or equal to 96.6% turn request accuracy on DSTC2, and less than or equal to 84.4% cumulative goal accuracy and less than or equal to 91.6% turn request accuracy on WoZ. Accordingly, it is desirable to develop neural network models for dialogue state trackers that achieve higher accuracy than current state of art dialogue state trackers. 
       FIG. 1A  is a simplified diagram of a digital system  100  with dialogue state tracking according to some embodiments. According to some embodiments, a user  110  may engage in a dialogue with digital system  100 . For example, user  110  may communicate with digital system  100  using any suitable form of communication, including verbal communication (e.g., spoken utterances), written communication (e.g., alphanumeric text and/or symbols), visual communication (e.g., gestures), and/or the like. In response, digital system  100  may provide one or more system responses (e.g., providing a response dialogue to user  110 , performing a task on behalf of user  110 , requesting additional information, and/or the like). 
     As depicted in  FIG. 1A , digital system  100  includes a controller  120  communicatively coupled to user  110  and/or a user device of user  110 . For example, user  110  may access controller  120  via a network. In some embodiments, controller  120  may include a processor  122  (e.g., one or more hardware processors). Although processor  122  may include one or more general purpose central processing units (CPUs), processor  122  may additionally or alternately include at least one processor that provides accelerated performance when evaluating neural network models. For example, processor  122  may include a graphics processing unit (GPU), an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a tensor processing unit (TPU), a digital signal processor (DSP), a single-instruction multiple-data (SIMD) processor, and/or the like. Generally, such processors may accelerate various computing tasks associated with evaluating neural network models (e.g., training, prediction, preprocessing, and/or the like) by an order of magnitude or more in comparison to a general purpose CPU. 
     Controller  120  may further include a memory  124  (e.g., one or more non-transitory memories). Memory  124  may include various types of short-term and/or long-term storage modules including cache memory, static random access memory (SRAM), dynamic random access memory (DRAM), non-volatile memory (NVM), flash memory, solid state drives (SSD), hard disk drives (HDD), optical storage media, magnetic tape, and/or the like. In some embodiments, memory  124  may store instructions that are executable by processor  122  to cause processor  122  to perform operations corresponding to processes disclosed herein and described in more detail below. 
     Processor  122  and/or memory  124  may be arranged in any suitable physical arrangement. In some embodiments, processor  122  and/or memory  124  may be implemented on a same board, in a same package (e.g., system-in-package), on a same chip (e.g., system-on-chip), and/or the like. In some embodiments, processor  122  and/or memory  124  may include distributed, virtualized, and/or containerized computing resources. Consistent with such embodiments, processor  122  and/or memory  124  may be located in one or more data centers and/or cloud computing facilities. 
     In some embodiments, memory  124  may store a dialogue state tracker  130  that maintains a dialogue state  132 . At each exchange of the dialogue (e.g., at each communication received from user  110  and/or system response provided by digital system  100 ), dialogue state tracker  130  may update dialogue state  132 . For example, dialogue state  132  may be updated to include one or more goals and/or requests expressed by user  110  over the course of the dialogue. Additionally or alternately, dialogue state tracker  130  may maintain a context  134 . For example, context  134  may include a history of one or more previous system responses by digital system  100  (e.g., previous actions taken), which provide context for a current communication received from user  110 . 
     In some embodiments, memory  124  may store an ontology set  140  that defines the range of user goals and/or requests that digital system  100  is equipped to handle. In some embodiments, ontology set  140  may include a plurality of ontology members, which are illustratively depicted in  FIG. 1A  as pairs of slots  142  and corresponding values  144 . As depicted in  FIG. 1A , slots  142  and values  144  are populated with illustrative examples corresponding to a scenario in which digital system  100  corresponds to a restaurant reservation system. In particular, slots  142  include two goal slots labeled “price range” and “area,” respectively. Values  144  corresponding to “price range” include “cheap” and “expensive.” Values  144  corresponding to “area” include “North,” “South,” “East,” and “West.” That is, user  110  may specify the price range and/or geographic area of restaurants at which digital system  100  may consider making a reservation. Slots  142  further include a pseudo-slot labeled “&lt;request&gt;,” which may be used to handle user requests. Values  144  corresponding to “&lt;request&gt;” include “phone” and “food.” That is, user  110  may request that digital system  100  provide a phone number and/or a type of cuisine for a restaurant. It is to be understood that these are merely examples, and that ontology set  140  may support a wide range of user goals and/or requests, which may be tailored to a particular application (e.g., restaurant reservations) and/or to a general-purpose application. 
     At each exchange of the dialogue, dialogue state tracker  130  may determine zero or more ontology members (e.g., pairs of slots and values from ontology set  140 ) to add to dialogue state  132 . For example, when user  110  expresses a desire to find a cheap restaurant, dialogue state tracker  130  may add the slot-value pair “price range=cheap” to dialogue state  132 . Similarly, dialogue state tracker  130  may determine zero or more ontology members to remove or replace in dialogue state  132 . For example, dialogue state tracker  130  may replace the slot-value pair “price range=expensive” with “price range=cheap” if user  110  previously expressed a desire for an expensive restaurant, but then changed the preference to a cheap restaurant. 
     To determine which ontology members (e.g., slot-value pairs from ontology set  140 ) to add to or remove from dialogue state  132  at a given exchange, dialogue state tracker  130  may include a scoring model  150  for evaluating member scores corresponding to the ontology members. Scoring model  150  may correspond to a neural network model that is evaluated by processor  122 . In particular, scoring model  150  may include a plurality of neural network layers. Examples of neural network layers include densely connected layers, convolutional layers, recurrent layers, pooling layers, dropout layers, and/or the like. In some embodiments, scoring model  150  may include at least one hidden layer that is not directly connected to either an input or an output of the neural network. Scoring model  150  may further include a plurality of model parameters (e.g., weights and/or biases) that are learned according to a machine learning process. Examples of machine learning processes include supervised learning, reinforcement learning, unsupervised learning, and/or the like. Embodiments of scoring model  150  are described in further detail below with reference to  FIGS. 2A-7 . 
     Scoring model  150  may be stored in memory  124  using any number of files and/or data structures. As depicted in  FIG. 1 , scoring model  150  includes a model description  152  that defines a computational graph of scoring model  150  (e.g., a sequence of neural network layers) and model parameters  154  that store parameters of scoring model  150  (e.g., weights and/or biases). In general, model description  152  and/or model parameters  154  may store information associated with scoring model  150  in any suitable format, including but not limited to structured, unstructured, serialized, and/or database formats. 
     In some embodiments, memory  124  may store a response module  160  that determines zero or more system responses to provide or perform in response to a given user communication based, at least in part, on dialogue state  132 . Examples of system responses include generating and sending a response dialogue to user  110 , performing a task on behalf of user  110 , requesting additional information from user  110 , and/or the like. In some embodiments, response module  160  may record the system response at a given exchange, e.g., by updating context  134 . In this manner, context  134  may provide context information to dialogue state tracker  130  based on previous actions taken by digital system  100 . 
       FIG. 1B  is a simplified diagram of an example dialogue  170  between user  110  and digital system  100  according to some embodiments. Example dialogue  170  generally corresponds to a dialogue from the WoZ restaurant reservation task. The columns depicted in  FIG. 1B  include an user communication column indicating an utterance or communication by user  110  at a given exchange, a context column that indicates any actions taken during the previous exchange by digital system  100  that are recorded in context  134 , updates to dialogue state  132  determined by dialogue state tracker  130  at a given exchange, and a response dialogue generated by response module  160  at a given exchange. 
     During the first exchange, the user states “Where would you go to eat in the south part of town?” Because this is the first exchange, there are no previous actions included in context  134 . Dialogue state tracker  130  determines that the user communication matches the slot-value pair “area=south” from ontology set  140 , which is represented as “Inform(area=south)” in dialogue state  132  to indicate that the slot-value pair corresponds to a user goal (as opposed to a user request). Digital system  100  responds “Ok I can help with that. Are your looking for a particular type of food, or within a specific price range?” 
     During the second exchange, the user states “I just want to eat at a cheap restaurant in the south part of town. What food types are available, can you also provide some phone numbers?” Context  134  indicates that during the previous exchange, digital system  100  requested that user  110  provide a food type (“Request(food)”) and a price range (“Request(price range”). Dialogue state tracker  130  determines that the user communication matches the slot-value pairs “price range=cheap,” “area=south,” “&lt;request&gt;=phone,” and “&lt;request&gt;=food” from ontology set  140 . The matching values from the “&lt;request&gt;” slot are represented as “Request(value)” in dialogue state  132  to indicate that the slot-value pair corresponds to a user request (as opposed to a user goal). Digital system  100  responds “I found two restaurants serving cheap food. Would you prefer Portuguese or Chinese food?” 
     During the third exchange, the user states “Either is fine, can I have the phone number please?” Context  134  indicates that during the previous exchange, digital system  100  requested that user  110  provide a food type (“Request(food)”). Dialogue state tracker  130  determines that the user communication matches the slot-value pair “&lt;request&gt;=phone” from ontology set  140 . Digital system  100  responds by providing the phone number for two restaurants that satisfy the criteria expressed by the user (i.e., cheap and located in the south part of town): “The lucky start is at 01223244277 and Nandos is at 01223327908.” The dialogue ends when user  110  replies “Thank you very much.” 
       FIGS. 2A-2C  are simplified diagrams of a scoring model  200  according to some embodiments. According to some embodiments consistent with  FIG. 1 , scoring model  200  may be used to implement scoring model  150 . As depicted in  FIGS. 2A-2C , scoring model  200  generally includes features similar to those described in “Neural Belief Tracker: Data-Driven Dialogue State Tracking,” to Mrkšić et al., published April 2017, which is hereby incorporated by reference in its entirety. 
     In some embodiments, scoring model  200  may receive an ontology member sequence  202 , a user communication sequence  204 , and zero or more context sequences  206  and generate a member score  208  corresponding to the received ontology member sequence  202 . In some embodiments, ontology member sequence  202  may correspond to a sequence of text representing a slot value and/or a slot-value pair of an ontology set, such as “cheap,” “price range=cheap,” and/or “Inform(price range=cheap),” from example dialogue  170 . In some embodiments, user communication sequence  204  may correspond to a sequence of text representing a user communication, such as “Where would you go to eat in the south part of town?” from example dialogue  170 . In some embodiments, context sequences  206  may include zero or more sequences of text that provide context associated with user communication sequence  204 . For example, context sequences  206  may correspond to text representations of previous actions taken by digital system  100 , such as “request(food)” and “request(price range)” from example dialogue  170 . 
     Member score  208  generally reflects the likelihood that the user communication under consideration matches or invokes the ontology member that is currently being evaluated (e.g., whether the user does in fact desire to find a restaurant in the “cheap” price range). Member score  208  may correspond to a numerical score, a ranking, a label (e.g., “high”/“low”), a grouping, a selection, and/or the like. In some embodiments, scoring model  200  may be evaluated (e.g., in parallel and/or in a serial manner) for each ontology member in an ontology set, such as ontology set  140 , yielding a set of member scores. Based on the set of member scores, a dialogue state tracker, such as dialogue state tracker  130 , may update the dialogue state, such as dialogue state  132 . For example, ontology members that are assigned member scores above a first threshold value may be added to the dialogue state, and ontology members with member scores below a second threshold value may be removed from the dialogue state. 
     Scoring model  200  may include input stages  212 ,  214 , and  216  that receive ontology member sequence  202 , user communication sequence  204 , and context sequences  206 , respectively, and generate input representations  222 ,  224 , and  226 , respectively. In some embodiments, input representations  222 ,  224 , and  226  may correspond to vector representations of sequences  202 ,  204 , and  206 , respectively. For example, when sequences  202 ,  204 , and/or  206  correspond to text sequences, input stages  212 ,  214 , and/or  216  may generate the corresponding vector representations by (1) tokenizing the text sequences and (2) embedding the tokenized text sequences in a vector space. Tokenizing the text sequences may include identifying tokens within the text sequences, where examples of tokens include characters, character n-grams, words, word n-grams, lemmas, phrases (e.g., noun phrases), sentences, paragraphs, and/or the like. Embedding the tokenized text sequences may include mapping each token to a vector representation in a multidimensional vector space. For example, a token corresponding to a word may be mapped to a 300-dimensional GloVe vector representation. 
     Scoring model  200  may further include encoder stages  232 ,  234 , and  236  that receive input representations  222 ,  224 , and  226 , respectively, and generates one or more encoded representations  242 ,  244 ,  245 , and/or  246 . Illustrative embodiments of encoder stages  232 ,  234 , and/or  236  are described in greater detail below with reference to  FIGS. 3 and 4 . 
     Scoring model  200  may further include a user communication scoring stage  250  that generates a user communication score  255  based on encoded representations  242  and  244 .  FIG. 2B  depicts an illustrative embodiment of user communication scorer stage  250 . As depicted in  FIG. 2B , user communication scoring stage  250  may include an attention layer  282  that generates an attended representation  284  based on encoded representations  242  and  244 . In particular, attended representation  284  may be generated by attending over a representation of the user communication (e.g., encoded representation  244 ) using a representation of the ontology member currently being evaluated (e.g., encoded representation  242 ). For example, attended representation  284  may be determined by evaluating the following equation: 
     
       
         
           
             
               q 
               utt 
             
             = 
             
               
                 ∑ 
                 i 
               
                
               
                 
                   p 
                   i 
                   utt 
                 
                  
                 
                   c 
                   i 
                   utt 
                 
               
             
           
         
       
     
     Where q utt  denotes attended representation  284 ; c i   utt  denotes the ith value of encoded representation  244 ; p i   utt  is defined as softmax(s utt ); the ith value of s utt  is defined as s i   utt =c i   utt ·c j   val ; and c j   val  denotes the jth value of encoded representation  242 . 
     User communication scoring stage  250  may further include a feed-forward layer  286  that generates user communication score  255  based on attended representation  284 . For example, user communication score  255  may be determined by evaluating the following equation: 
     
       
      
       y 
       utt 
       =W 
       utt 
       q 
       utt 
       +b 
       utt  
      
     
     Where y utt  denotes user communication score  255 , W utt  denotes a parameter matrix containing learned weights, and b utt  denotes a learned bias value. 
     Scoring model  200  may further include a context scorer stage  260  that generates a context score  265  based on encoded representations  242 ,  245 , and  246 .  FIG. 2C  depicts an illustrative embodiment of context scoring stage  260 . As depicted in  FIG. 2C , context scoring stage  260  may include an attention layer  292  that generates an attended representation  294  based on encoded representations  242 ,  245 , and  246 . In particular, attended representation  294  may be generated by attending over a representation of the context (e.g., encoded representation  246 ) using a representation of the user communication (e.g., encoded representation  245 ). For example, attended representation  294  may be determined by evaluating the following equation: 
     
       
         
           
             
               q 
               ctx 
             
             = 
             
               
                 ∑ 
                 i 
               
                
               
                 
                   p 
                   i 
                   ctx 
                 
                  
                 
                   c 
                   i 
                   ctx 
                 
               
             
           
         
       
     
     Where q ctx  denotes attended representation  284 ; c i   ctx  denotes the ith value of encoded representation  246 ; p i   ctx  is defined as softmax(s ctx ); the ith value of s ctx  is defined as s i   ctx =c i   ctx ·c j   utt ; and c j   utt  denotes the jth value of encoded representation  245 . 
     Context scoring stage  260  may further include a multiplication layer  296  that generates context score  265  based on attended representation  294 . For example, context score  265  may be determined by evaluating the following equation: 
     
       
      
       y 
       ctx 
       =q 
       ctx 
       ·c 
       val  
      
     
     Where y ctx  denotes context score  265  and c val  denotes encoded representation  242 . 
     Returning to  FIG. 2A , scoring model  200  may further include a score combiner stage  270  that determines member score  208  based on a combination of user communication score  255  and context score  265 . In illustrative embodiments, member score  208  may be determined by evaluating the following equation 
         y =σ( y   utt   +w   y   y   ctx )
 
     Where y denotes member score  208 , σ denotes a sigmoid function, and w y  denotes a learned weighting parameter. 
     According to some embodiments, scoring model  200  may correspond to a computational graph, in which case various stages (e.g., input stages  212 - 216 , encoder stages  232 - 236 , scoring stages  250  and/or  260 , and/or score combiner stage  270 ) may correspond to collections of nodes in the computational graph. Consistent with such embodiments, various representations used by scoring model  200  (e.g., input representations  222 - 226 , encoded representations  242 - 246 , and/or any intermediate representations used by scoring model  200 ) may correspond to real-valued tensors (e.g., scalars, vectors, multidimensional arrays, and/or the like) that are passed along edges of the computational graph. Moreover, each node of the computation graph may perform one or more tensor operations, e.g., transforming one or more input representations of the node into one or more output representations of the node. Examples of tensor operations performed at various nodes may include matrix multiplication, n-dimensional convolution, normalization, element-wise operations, and/or the like. 
       FIG. 3  is a simplified diagram of an encoder  300  according to some embodiments. According to some embodiments consistent with  FIGS. 1A-2C , encoder  300  may be used to implement one or more of encoder stages  232 - 236 . Consistent with such embodiments, encoder  300  may receive an input representation  302  and generate one or more encoded representations  304  and/or  306 . In embodiments consistent with  FIGS. 1A-2C , input representation  302  may generally correspond to any of input representations  222 - 226 , encoded representation  304  may generally correspond to encoded representation  244 , and encoded representation  306  may generally correspond to any of encoded representations  242 ,  245 , and/or  246 . 
     In some embodiments, encoder  300  may include a recurrent neural network (RNN) layer  310  that receives input representation  302  and generates encoded representation  304 . In general, an RNN layer injects sequence-related information (e.g., temporal information) into the transformed representation. For example, the RNN layer may include a sequence of simple RNN cells, long short-term memory (LSTM) cells, gated recurrent units (GRUs), and/or the like. In some examples, RNN layer  310  may be bi-directional, e.g., a bi-directional LSTM (Bi-LSTM) layer. For example, when RNN layer  310  includes a Bi-LSTM layer, encoded representation  304  may include a set of intermediate LSTM states. 
     In some embodiments, encoder  300  may include a self-attention layer  320  that receives encoded representation  304  and generates encoded representation  306 . In particular, encoded representation  306  may be generated by self-attending over encoded representation  304 . For example, encoded representation  306  may be determined by evaluating the following equation: 
     
       
         
           
             c 
             = 
             
               
                 ∑ 
                 i 
               
                
               
                 
                   p 
                   i 
                 
                  
                 
                   H 
                   i 
                 
               
             
           
         
       
     
     Where c denotes encoded representation  306 ; H i  denotes the ith value of encoded representation  304 ; p i  is defined as softmax(s); the ith value of s is defined as s i =WH i +b; W denotes a parameter matrix containing learned weights; and b denotes a learned bias. 
     In some embodiments, encoder  300  may include local trained parameters that are determined separately for each ontology member of an ontology set, such as ontology set  140 . The use of local trained parameters may improve the accuracy of encoder  300  by separately tuning the trained parameters for each ontology member in the ontology set. 
     One challenge associated with local trained parameters is that the use of local trained parameters limits the number of training examples in which the corresponding ontology member occurs. The challenge is particularly exacerbated for ontology members that occur rarely in practice (e.g., users may rarely request to eat at expensive restaurants, meaning training data sets tend to include very few examples in which a user communication expresses such a request). Large ontology sets are also likely to include a large number of ontology members, each of which is individually unlikely to occur in a given turn, but at least one of which is collectively likely to occur in a given turn. For example, a travel reservation system may be configured to handle requests for vast number of potential travel destinations around the world. Accordingly, the likelihood that a user&#39;s request identifies at least one destination is high, but the likelihood that the requested destination is a particular destination (e.g., “Paris, France”) among all possible destinations is low. The problem may be quantified with reference to particular training data sets. For example, in the WoZ state tracking data set, although each slot-value pair occurs in 214.9 training examples on average, the set includes a number of rare slot-value pairs exist that occur in less than 20 training examples. Moreover, although such rare slot-value pairs are individually uncommon, they collectively occur frequently: 38.6% of turns in the WoZ dataset have a goal that contains a rare (fewer than 20 training examples) slot-value pair. 
     To address this challenge, encoder  300  may include global trained parameters that are shared among the ontology members of the ontology set. The use of global trained parameters may improve the performance of encoder  300 , particularly with respect to rarely occurring ontology members, by expanding the scope of the training process to the full ontology set. However, overall accuracy may decline when using global trained parameters, as the global trained parameters are not tuned to particular ontology members. 
       FIG. 4  is a simplified diagram of a global-local encoder  400  according to some embodiments. Relative to encoder  300 , global-local encoder  400  may be used to train scoring model  200  with a combination of local trained parameters and global trained parameters. Accordingly, global-local encoder  400  may harness the benefits of both local trained parameters (e.g., improved accuracy for frequently occurring ontology members for which a large number of training examples are available) and global trained parameters (e.g., improved accuracy for rarely occurring ontology members for which few training examples are available). 
     According to some embodiments consistent with  FIGS. 1A-2C , global-local encoder  400  may be used to implement one or more of encoder stages  232 - 236 . Consistent with such embodiments, global-local encoder  400  may receive an input representation  402  and generate one or more encoded representations  404  and/or  406 . In embodiments consistent with  FIGS. 1A-2C , input representation  402  may generally correspond to any of input representations  222 - 226 , encoded representation  404  may generally correspond to encoded representation  244 , and encoded representation  406  may generally correspond to any of encoded representations  242 ,  245 , and/or  246 . It is to be understood, however, that global-local encoder  400  may be generally used in a wide variety of models other than scoring model  200 , e.g., scoring models with different architectures than that of scoring model  200 . 
     In some embodiments, global-local encoder  400  may include one or more global branches (e.g., branches that include global trained parameters that are shared among the plurality of ontology members) and one or more local branches (e.g., branches that include local trained parameters that are determined separately for each of the plurality of ontology members). In some embodiments, a given global branch may be arranged in parallel with a corresponding local branch. For example, as depicted in  FIG. 4 , global-local encoder  400  includes a first global branch that includes a global recurrent neural network (RNN) layer  41 , and a first local branch that includes a local RNN layer  420 , where the first global branch and the first local branch are arranged in parallel. Global RNN layer  410  receives input representation  402  and generates a global encoded representation  415 , and local RNN layer  420  receives input representation  402  and generates a local encoded representation  425 . Whereas global RNN layer  410  may include global trained parameters that are shared among the ontology members of the ontology set, local RNN layer  420  may include local trained parameters that are determined separately for each ontology member of the ontology set. As previously discussed, an RNN layer injects sequence-related information (e.g., temporal information) into the transformed representation. For example, the RNN layer may include a sequence of simple RNN cells, long short-term memory (LSTM) cells, gated recurrent units (GRUs), and/or the like. In some examples, RNN layers  410  and/or  420  may be bi-directional, e.g., a bi-directional LSTM (Bi-LSTM) layer. For example, when RNN layers  410  and/or  420  include a Bi-LSTM layer, encoded representations  415  and/or  425  may include a set of intermediate LSTM states. 
     Global-local encoder  400  may include a merge module  430  to combine global encoded representation  415  and local encoded representation  425  and generate encoded representation  404 . In some embodiments, merge module  430  may include local trained parameters that are determined separately for each ontology member of the ontology set, global trained parameters that are shared among the ontology members of the ontology set, and/or any suitable combination thereof. In illustrative embodiments, encoded representation  404  may correspond to a weighted average of global encoded representation  415  and local encoded representation  425  with a local weighting parameter, which may be determined by evaluating the following equation: 
       ƒ′( x )=σ(α s )ƒ s ( x )+(1−σ(α s ))ƒ g ( x )
 
     Where x denotes input representation  402 ; ƒ′(x) denotes encoded representation  404 ; ƒ s (x) denotes local encoded representation  425 ; ƒ g (x) denotes global encoded representation  415 ; a denotes a sigmoid function; and as denotes a learned, local weighting parameter that is determined for a given ontology member s. 
     In some embodiments, global-local encoder  400  may include a second global branch that includes a global self-attention layer  440  and a second local branch that includes a local self-attention layer  450 , where the second global branch and the second local branch are arranged in parallel. Global self-attention layer  440  receives encoded representation  404  and generates a global encoded representation  445 , and local self-attention layer  450  receives encoded representation  404  and generates a local encoded representation  455 . As previously discussed with respect to  FIG. 3 , global encoded representation  445  and/or local encoded representation  455  may be generated by self-attending over encoded representation  404 . For example, global encoded representation  445  (or local encoded representation  455 ) may be determined by evaluating the following equation: 
     
       
         
           
             c 
             = 
             
               
                 ∑ 
                 i 
               
                
               
                 
                   p 
                   i 
                 
                  
                 
                   H 
                   i 
                 
               
             
           
         
       
     
     Where c denotes global encoded representation  445  (or local encoded representation  455 ); H i  denotes the ith value of encoded representation  404 ; p i  is defined as softmax(s); the ith value of s is defined as s i =WH i +b; W denotes a parameter matrix containing learned weights; and b denotes a learned bias. In the case of global self-attention layer  440 , the learned weights and/or the learned bias may be global trained parameters that are shared among the ontology members of the ontology set. In the case of local self-attention layer  450 , the learned weights and/or the learned bias may be local trained parameters that are determined separately for each ontology member of the ontology set. 
     Global-local encoder  400  may include a merge module  460  to combine global encoded representation  445  and local encoded representation  455  and generate encoded representation  406 . In general, merge module  460  may operate in a manner similar to merge module  430 . For example, encoded representation  406  may correspond to a weighted average of global encoded representation  445  and local encoded representation  455  with a local weighting parameter, which may be determined by evaluating the following equation: 
       ƒ′( x )=σ(α s )ƒ s ( x )+(1−σ(α s ))ƒ g ( x )
 
     Where x denotes encoded representation  404 ; ƒ′(x) denotes encoded representation  406 ; ƒ s (x) denotes local encoded representation  455 ; ƒ g  (x) denotes global encoded representation  445 ; σ denotes a sigmoid function; and α s  denotes a learned, local weighting parameter for a given ontology member s. 
       FIG. 5  is a simplified diagram of a training configuration  500  for a neural network model according to some embodiments. As depicted in  FIG. 5 , training configuration  500  is used to train a model  510 . In some embodiments consistent with  FIGS. 1-4 , model  510  may be used to implement scoring model  200 . 
     According to some embodiments, training configuration  500  may be used to train a plurality of model parameters of model  510 . During training, a large number of training examples (e.g., user communication sequences, context sequences, and/or ontology member sequences) are provided to model  510 . The predicted member scores generated by model  510  are compared to a ground truth answers for each of the examples using a learning objective  520 , which determines a loss and/or reward associated with a given predicted member score based on the ground truth answer. 
     The output of learning objective  520  (e.g., the loss and/or reward) is provided to an optimizer  530  to update the model parameters of model  510 . For example, optimizer  530  may determine the gradient of the objective with respect to the model parameters and adjust the model parameters using back propagation. In some embodiments, optimizer  530  may include a gradient descent optimizer (e.g., stochastic gradient descent (SGD) optimizer), an ADAM optimizer, an Adagrad optimizer, an RMSprop optimizer, and/or the like. Various parameters may be supplied to optimizer  530  (e.g., a learning rate, a decay parameter, and/or the like) depending on the type of optimizer used. 
       FIG. 6  is a simplified diagram of a method  600  for maintaining a dialogue state associated with a dialogue between a user and a digital system, such as digital system  100 , according to some embodiments. According to some embodiments consistent with  FIGS. 1-5 , all or portions of method  600  may be performed using a processor, such as processor  122 . In some embodiments, all or portions of method  600  may be performed by evaluating a neural network model, such as scoring models  150  and/or  200 . 
     At a process  610 , a dialogue state, such as dialogue state  132 , is updated based on a user communication (or a digital representation thereof, the representation having been received, e.g., from a user device). In some embodiments, the dialogue state may be updated using a dialogue state tracker associated with the digital system, such as dialogue state tracker  130 . Consistent with such embodiments, the dialogue state tracker may evaluate a scoring model, such as scoring model  150 , to determine a plurality of member scores corresponding to a plurality of ontology members of an ontology set, such as ontology set  140 . In some embodiments, the scoring model may generate each of the member scores based on the user communication, the ontology member under consideration, and/or contextual information, such as context  134 . Based on the member scores, the dialogue state tracker may update the dialogue state. For example, the dialogue state tracker may select zero or more ontology members to add to or remove from the dialogue state based on the member scores (e.g., by selecting ontology members with member scores that exceed or fall below a predetermined threshold value). In some embodiments, the dialogue state may include cumulative goals (e.g., a set of goals expressed by the user up to the current exchange in the dialogue) and/or turn requests (e.g., a set of requests expressed by the user during the current exchange). 
     At a process  620 , a system response is provided based on the updated dialogue state. In some embodiments, the system response may be provided using a response module, such as response module  160 . In some embodiments, the system response may include performing a task on behalf of the user (e.g., searching a database, making a restaurant reservation, and/or the like), providing a response dialogue to the user, requesting additional information from the user, and/or the like. In some embodiments, the response module may record one or more actions taken at process  620 , e.g., by updating the contextual information. Accordingly, when method  600  is repeated during subsequent exchanges of a dialogue with the user, the dialogue state tracker may access the updated contextual information when updating the dialogue state. 
       FIG. 7  is a simplified diagram of a method  700  for training a neural network model according to some embodiments. According to some embodiments consistent with  FIGS. 1-6 , method  700  may be used to train a neural network model, such as scoring models  150  and/or  200 . During training, the model may be configured in a training configuration, such as training configuration  500 . In some examples, method  700  may be performed iteratively over a large number of training examples to gradually train the neural network model. 
     At a process  710 , cumulative goals and/or turn requests are predicted using the neural network model. In some embodiments, the cumulative goals and/or turn requests may be generated based on a training example that includes a training communication. In some embodiments, the cumulative goals and/or turn requests may be generated according to method  600 . 
     At a process  720 , a learning objective is evaluated based on the cumulative goals and/or turn requests. In some embodiments, the learning objective may correspond to learning objective  520 . In some embodiments, the learning objective may be evaluated by comparing the cumulative goals and/or turn requests predicted at process  710  to a ground truth answer corresponding to the training communication. 
     At a process  730 , the parameters of the neural network model are updated based on the learning objective. In some embodiments, the model parameters may be updated using an optimizer, such as optimizer  530 . In some embodiments, the parameters may be updated by determining a gradient of the learning objective with respect to the model parameters and updating the parameters based on the gradient. The gradient of the learning objective may be determined by back propagation. 
       FIGS. 8A and 8B  are simplified diagrams of an experimental evaluation of a dialogue state tracker according to some embodiments. The dialogue state tracker being evaluated includes a scoring model, configured as depicted in  FIG. 3 , and different versions of the dialogue state tracker are trained on the WoZ and DSTC2 data sets. 
       FIG. 8A  depicts a table  810  that compares the accuracy of a dialogue state tracker of the present disclosure (last row) to the accuracy of other types of dialogue state trackers (other rows). As indicated in the table, the dialogue state tracker of the present disclosure achieves the highest accuracy across all metrics, including 74.8% cumulative goal accuracy and 97.3% turn request accuracy on the DSTC2 data set and 88.3% cumulative goal accuracy and 96.4% turn request accuracy on the WoZ data set. 
       FIG. 8B  depicts a table  820  that includes the results of an ablation study of a dialogue state tracker of the present disclosure, trained and tested on the WoZ data set. The top row corresponds to a dialogue state tracker with a global-local encoder configured as depicted in  FIG. 4 , using a combination of global and local trained parameters. The second row corresponds to a dialogue state tracker with an encoder configured as depicted in  FIG. 3 , using local trained parameters. The second row corresponds to a dialogue state tracker with an encoder configured as depicted in  FIG. 3 , using global trained parameters. The third row corresponds to a dialogue state tracker with a global-local encoder configured as depicted in  FIG. 4 , but without self-attention layers (e.g., without global self-attention layer  440  and/or local self-attention layer  450 ). The third row corresponds to a dialogue state tracker with a global-local encoder configured as depicted in  FIG. 4 , but without recurrent layers (e.g., without global RNN layer  410  and/or local RNN layer  420 ). As indicated in the table, removing the various features results in a decrease of between 1.2% and 17.3% in cumulative goal accuracy and a decrease of between 0% and 4.1% in turn request accuracy. 
     Although illustrative embodiments have been shown and described, a wide range of modifications, changes and substitutions are contemplated in the foregoing disclosure and in some instances, some features of the embodiments may be employed without a corresponding use of other features. One of ordinary skill in the art would recognize many variations, alternatives, and modifications. Thus, the scope of the present application should be limited only by the following claims, and it is appropriate that the claims be construed broadly and in a manner consistent with the scope of the embodiments disclosed herein.