Individual differences in speakers are reflected in their language use as well as in their interests and opinions. Characterizing these differences can be useful in human-computer interaction, as well as analysis of human-human conversations. In this work, we introduce a neural model for learning a dynamically updated speaker embedding in a conversational context. Initial model training is unsupervised, using context-sensitive language generation as an objective, with the context being the conversation history. Further fine-tuning can leverage task-dependent supervised training. The learned neural representation of speakers is shown to be useful for content ranking in a socialbot and dialog act prediction in human-human conversations. 1 1 Introduction Representing language in context is key to improving natural language processing (NLP). There are a variety of useful contexts, including word history, related documents, author/speaker information, social context, knowledge graphs, visual or situational grounding, etc. This paper addresses the problem of modeling the speaker. Accounting for author/speaker variations has been shown to be useful in many NLP tasks, including language understanding (Hovy and Sgaard, 2015; Volkova et al., 2013), language generation (Mirkin et al., 2015; Li et al., 2016), human-computer dialog policy (Bowden et al., 2018), query completion (Jaech and Ostendorf, 2018; Shokouhi, 2013), comment recommendation (Agarwal et al., 2011) and more. In this work, we specifically focus on dialogs, including both human-computer (social-bot) and human-human conversations. While many studies rely only on discrete meta-data and/or demographic information, such information is not always available. Thus, it is of interest to learn about the speaker from the language directly, as it relates to the person's interests and speaking style. Motivated by the success of unsupervised contextualized representation learning for words and documents (Mikolov et al., 2013; Kiros et al., 2015; McCann et al., 2017; Peters et al., 2018; Devlin et al., 2019), our approach is to use unsupervised learning with a neural model of a speaker's dialog history. The model uses latent speaker mode vectors for representing a speaker turn as in (Cheng et al., 2017), which provides a framework for analysis of what the model learns about speaking style. Further, the model is structured to allow a dynamic update of the speaker vector at each turn in a dialog, in order to capture changes over time and improve the speaker representation with added data. The speaker embeddings can be used as context in conversational language understanding tasks, e.g., as an additional input in dialog policy prediction in human-computer dialogs or in understanding dialog acts in human-human dialogs. In the supervised training of such tasks, the speaker model can be fine-tuned. This work makes two primary contributions. First, we propose a neural model for learning dynamically updated speaker embeddings in conversational interactions. The model training is unsupervised, relying on only the speaker's conversation history rather than meta information (e.g., age, gender) or audio signals which may not be available in a privacy-sensitive situation. The model also has a learnable component for analyzing the latent modes of the speaker, which can be helpful for aligning the learned characteristics of a speaker with the human-interpretable factors. Second, we use the learned dynamic speaker embed-Speaker State Tracker  1  0    +1 Latent Mode Analyzer  1 Global Mode Vectors   Attention      ,   ,1  ,  +1  ,1  ,0  ,0  ,  Speaker Language Predictor  ,1  ,   ,1 </s> Conversation-LevelTurn-Level Figure 1: The dynamic speaker model. dings in two representative tasks in dialogs: predicting user topic decisions in socialbot dialogs, and classifying dialog acts in human-human dialogs. Empirical results show that using the dynamic speaker embeddings significantly outperforms the baselines in both tasks. In the public dialog act classification task, the proposed model achieves the state-of-the-art results. In this section, we start with an overview of the proposed model for learning speaker embeddings that are dynamically refined over the course of a conversation. Details about individual components are described in subsequent subsections. The model is based on two motivations. First, a speaker's utterances reflect intents, speaking style, etc. Thus, we may build speaker embeddings by analyzing latent modes that characterize utterances in terms of such characteristics, apart from topic-related interests a user might have. Second, the information about a speaker is accumulated as the conversation evolves, which allows us to gradually refine and update the speaker embeddings. The speaker embeddings can be directly used as features or fine-tuned based on the downstream tasks. We design the dynamic speaker model to focus on learning cues from the speaker's utterances, and leave the modeling of different speaker-addressee interactions for supervised downstream tasks. The model consists of three components as illustrated in Fig. 1. First, a latent mode analyzer reads in an utterance and analyzes its latent modes. It processes the speaker's turns independently of each other and builds a local speaker mode vector for each turn. To accumulate speaker information as the conversation evolves, we build a speaker state tracker that maintains speaker states at individual turns. At each turn, it takes two input vectors to update the speaker state: 1) the local speaker mode vector for the current turn from the latent mode analyzer, and 2) the speaker state at the previous turn from the tracker itself. Finally, we employ a speaker language predictor to drive the learning of the latent model analyzer and the speaker state tracker. It reconstructs the utterance using the corresponding speaker state. Intuitively, the speaker language predictor models overall linguistic regularities itself and uses the speaker state to supply information related to speaker characteristics. For sequence modeling in all three components, we use the long short-term memory (LSTM) recurrent neural network (Hochreiter and Schmidhuber, 1997). In our experiments, the three components are trained jointly. At each turn t , the latent mode analyzer constructs a local speaker mode vector  u t  R c that captures salient characteristics of the speaker's current utterance for use in the dynamic speaker model. First, the utterance word sequence w t, 1 ,    , w t,N t is mapped to an embedding sequence, where w t,n is represented with w t,n  R d according a lookup with dictionary W  R |V| d associated with vocabulary V . Then, the latent mode analyzer goes through two stages to construct  u t . In the first stage, a bi-directional LSTM (Bi-LSTM), which consists of a forward LSTM and a backward LSTM, is used to encode the word embedding sequence into a fixed-size utterance summary vector s t  R 2 m , where m is the dimension of the hidden layer in the forward and backward LSTMs. Formally, the forward LSTM computes its hidden states as e Ft,n = g F ( w t,n , e Ft,n  1 )  R m for n = 1 , . . . , N t , where g F (  ,  ) denotes the forward LSTM function. The backward LSTM computes its hidden states e Bt,n  R m similarly. The initial hidden states e Ft, 0 and e Bt,N t +1 are set to zeros. The summary vector s t is the concatenation of the two final hidden states, s t = [ e Ft,N t , e Bt, 1 ] . In the second stage, the utterance summary vector s t is compared with K global mode vectors u 1 , . . . , u K  R c which are learned as part of the model. The association score a t,k between s t and u k is computed using the dot-product attention mechanism (Vaswani et al., 2017) as follows, a t,k = exp( (cid:104) Ps t , Qu k (cid:105) ) (cid:80) Kk (cid:48) =1 exp( (cid:104) Ps t , Qu k (cid:48) (cid:105) ) , (1) where P  R c  2 m and Q  R c  c are learnable weights, and (cid:104) , (cid:105) indicates the dot-product of two vectors. The local speaker mode vector is then constructed as  u t = (cid:80) Kk =1 a t,k u k . The speaker state tracker provides a dynamic summary of speaker language features observed in the conversation history, using an LSTM to encode the sequence of local speaker mode vectors  u t, 1 ,    ,  u t,N t . At turn t , this LSTM updates its hidden state h t  R m using the local speaker mode vector  u t and its previous hidden state h t  1  R m , i.e., h t = g S ( u t , h t  1 ) , where g S (  ,  ) is the speaker LSTM function. The hidden state h t provides the speaker state vector at turn t . The speaker language predictor is a conditional LSTM language model (LM) that reconstructs the word sequence in the current turn. Language modeling is a way to provide a training signal for unsupervised learning that models the conditional probability Pr( w t,n | w t,<n ) , where w t,<n denotes all preceding words of w t,n in the turn t . The speaker language predictor uses the same dictionary W for word embeddings as the latent mode analyzer to represent words at time t . The initial hidden state d t, 0  R m of the LSTM is set to tanh( Lh t ) , where L  R m  m is a learnable matrix and tanh(  ) is the hyperbolic tangent function. Subsequent LSTM hidden states are computed as d t,n = g LM ( r I ( w t,n  1 , h t ) , d t,n  1 ) , for n = 1 , . . . , N t + 1 , where r I ( w t,n  1 , h t ) = R Iw w t,n  1 + R Ih h t is a linear transformation with learned parameters R Iw  R m  d and R Ih  R m  m , g LM (  ,  ) is a forward LSTM function, and w t, 0 is the word embedding for the start-of-sentence token. By injecting the speaker state vector at every time step n in the turn t , the model is more likely to favor directly using the speaker state vector (vs. the word history) for predicting the speaker language. The conditional probability is then computed as Pr( w t,n | w t,<n ) = softmax( V r O ( h t , d t,n )) , (2) where V  R |V| m is the weight matrix, and r O ( h t , d t,n ) = R Oh h t + R Od d t,n is another linear function with learnable parameters R Oh , R Od  R m  m . The last word w t,N t +1 is always the end-of-sentence token. The training objective for a given conversation is the log-likelihood (cid:80) t (cid:80) n log Pr( w t,n | w t,<n ) , where the conditional probability is defined in (2). The Adam optimizer (Kingma and Ba, 2015) is used with a configuration of  1 = 0 . 9 and  2 = 0 . 97 . The initial learning rate is set to 0 . 002 . We halve the learning rate at each epoch once the development log-likelihood decreases, and terminate the training when it decreases for the second time. This validation protocol is used throughout the paper for training the proposed model. In our experiments, the embedding dictionary W is initialized using pre-trained 300-dimensional word embeddings (Bojanowski et al., 2017) for words within the vocabulary of this resource. The remaining part of W and other model parameters are randomly initialized based on N (0 , 0 . 01) . The mode vector dimension c is set to 64 . We tune the number of global mode vectors K from { 16 , 32 } and the hidden layer size m from { 128 , 160 } . The final model is selected based on the log-likelihood on the development set. We first study a prediction task that estimates whether the user engaged in a socialbot conversation would accept a suggested topic. Specifically, we use a corpus of human-socialbot conversations collected during the 2017 Alexa Prize competition (Ram et al., 2017) from the Sounding Board system (Fang et al., 2018; Fang, 2019). Due to privacy concerns, the socialbot does not have access to any identity information about users. Also, since each device may be used by multiple users, the device address is not a reliable indicator of the user ID. Therefore, the ability to profile the user through one conversational interaction is desirable for guiding the socialbot's dialog policy. Each conversation begins with a greeting and ends when the user makes a stop command. The socialbot engages the user in the conversation using a wide range of content indexed by topics, where a topic corresponds to a noun or noun phrase that refers to a named entity (e.g., Google) or a concept (e.g., artificial intelligence). These topics are extracted using both constituency parsing results of the textual content and content meta-information. During the conversation, the socialbot sometimes negotiates the topic with the user using an explicit confirmation turn and records the user's binary decision (accept or reject) on the topic. In socialbot conversations, a system turn is always followed by a user turn and vice versa. We tag system turns making explicit confirmation about a topic and attach the corresponding binary user decisions with them. To curate the dataset for the topic decision prediction task, we use a total of 31,862 conversations with more than 5 user turns. On average there are around 22 user turns per conversation. Not every system turn makes a topic suggestion, and the average number of topic decisions per conversation is 4.5. We randomly split the conversations into training, development, and test sets by 3 / 1 / 1 . The data statistics are shown in Table 1. In our experiments, we directly use the speech recognition output of user utterances. The vocabulary V consists of roughly 11 K words that appear at least 5 times in the training set. We use a feed-forward neural network (FFNN) to make binary predictions (accept vs. reject) for individual topic suggestions. For each topic suggestion, the FFNN takes two inputs: 1) an embedding x t (cid:48) for the suggested topic at system turn t (cid:48) , and 2) a user embedding vector z t at user turn t . Note the model does not have information about user turns after the system turn t (cid:48) when making the prediction, i.e., the user turn t appears before the system turn t (cid:48) . The topic embedding x t (cid:48) 's are looked up from the embedding dictionary learned by the FFNN. They are initialized by averaging the embeddings of their component words using the public pre-trained 300-dimensional word embeddings (Bo-janowski et al., 2017). For the user embedding vector, we explore two settings that use different numbers of user turns as context. In both settings, topic decisions occurring in the first 5 user turns are not used for evaluations. Static User Embeddings : Motivated by the findings that most user characteristics can be inferred from initial interactions (Ravichander and Black, 2018), we derive a static user embedding vector for a conversation using the first 5 user turns and apply it for predicting topic decisions afterwards. Dynamic User Embeddings : Alternatively, we build a user embedding vector for user turn t using all previous user turns. Here, a topic decision for system turn t (cid:48) is aligned with its preceding user turn t . In our experiments, we compare different unsupervised models with our proposed dynamic speaker model. For both settings, all unsupervised models are pre-trained on all user turns in training conversations. They are fixed when training the FFNN classifier. The FFNN classifier is trained with the logistic loss using the Adam optimizer (Kingma and Ba, 2015). The training protocol is similar to that described in 2.4. We tune the hidden layer size from { 64 , 128 } and the number of hidden layers from { 0 , 1 } . The model is selected based on the loss on the development set. In addition, we use a user-agnostic TopicPrior baseline. It builds a probability lookup for each topic using its acceptance rate on the training set. We tune a universal probability threshold for all topics based on the development set accuracy. In all experiments, three evaluation metrics are used: accuracy, area under the receiver operating characteristic curve (AUC), and normalized cross-entropy (N-CE). N-CE is computed as the relative cross-entropy reduction of the model over the TopicPrior baseline. As described in 3.2, we use the first 5 user turns to derive the user embedding vector for a conversation. We compare our dynamic speaker model with three other unsupervised models. DynamicSpeakerModel : For the proposed dynamic speaker model, we concatenate the speaker state vector h t and the local speaker mode vector Model Acc AUC N-CE TopicPrior 68.8 72.5 0 UtteranceLDA 68.8 73.1 12.6 UtteranceAE 68.8 73.4 12.8 TopicDecisionEncoder 68.9 73.8 13.4 DynamicSpeakerModel 69.5 74.2 13.7 Table 2: Test set results (in %) for topic decision predictions using static user embeddings. u t for each of the first 5 user turns. Then, we apply the max-pooling operation over the 5 concatenated vectors to summarize all the information. The resulting vector  h is used as the user embedding vector. UtteranceLDA : The latent Dirichlet allocation (LDA) model (Blei et al., 2003) is trained with 16 latent groups by treating all user utterances in a conversation as a document. 2 The trained LDA model builds a 16-dimensional probability vector as the user embedding vector by loading the first 5 user turns as a single document. UtteranceAE : The utterance auto-encoder model is built upon the sequence auto-encoder (Dai and Le, 2015). We replace the original encoder by a BiLSTM that encodes the utterance at user turn t into a summary vector s t in the same way as the first stage of the latent mode analyzer described in 2.1. The auto-encoder is trained on all user utterances in the training data, using the same training protocol described in 2.4. We set the hidden layer size to 128 . The user embedding vector is constructed by applying the max-pooling operation over the summary vectors s 1 , . . . , s 5 for the first 5 user turns. TopicDecisionEncoder : This model encodes the topic decisions occurred in the first 5 user turns. The user embedding vector is the concatenation of two vectors. One is max-pooled from the topic embeddings for accepted topics, and the other for rejected topics, both include a dummy topic vector as default. The topic embeddings are composed by averaging the public pre-trained 300-dimensional embeddings (Bojanowski et al., 2017) for words in the topic. Experiment results are summarized in Table 2. The TopicPrior is a very strong predictor, with an 2 To allow the LDA model to take into account bi-grams, we replace the uni-gram token w i with its bi-gram ( w i , w i +1 ) concatenated as a single token if the bi-gram is among the top 500 frequent bi-grams. accuracy on par with other user embeddings. This indicates that the popularity-based approach is a good start for content ranking in socialbots when there is little user information. Nevertheless, we can still observe some improvement over the TopicPrior in terms of AUC and N-CE, which suggests using information from initial interactions reduces the uncertainty of predictions. The proposed dynamic speaker model performs the best among the compared models, reducing the cross-entropy by 13.7% over the TopicPrior baseline. Here, we use all information accumulated before the system turn of suggesting the topic to build the corresponding user embedding vector. Since the UtteranceLDA is not as effective based on static embedding experiments, we only consider extending UtteranceAE and TopicDecisionEncoder models for comparison here. DynamicSpeakerModel : The speaker state tracker in our model accumulates the user information as the conversation evolves. Thus, we directly concatenate the speaker state vector h t and the local speaker mode vector  u t as the user embedding vector at user turn t . Other than using more turns, this is the same DynamicSpeakerModel configuration as in 3.3. UtteranceAE+LSTM : This model uses an LSTM to encode the summary vector sequence derived from the same utterance auto-encoder used in 3.3. The LSTM hidden states are treated as user embedding vectors at individual user turns. TopicDecisionLSTM : Similarly, an LSTM is used to encode the topic decision sequence. At each time step, the LSTM reads the concatenation of the topic embedding and the one-hot vector encoding the topic decision. We use the same topic embeddings as the TopicDecisionEncoder in 3.3. Since not every user turn is associated with a topic decision, the time steps of this LSTM are aligned to a sequence of non-consecutive user turns. The LSTM hidden states are treated as user embedding vectors at corresponding user turns. For UtteranceAE+LSTM and TopicDecisionLSTM, the hidden layer size of the LSTM is set to 128. While the utterance auto-encoder and topic embeddings are pre-trained, the LSTM components are jointly learned with the FFNN for composing dynamic user embeddings. Experiment results are shown in Table 3. The DynamicSpeakerModel performs the best. Comparing to results in Table 2, all three unsupervised models outperform their static counterparts, which suggests the advantage of using dynamic context for predicting user topic decisions as conversation evolves. Statistical significance tests of the difference in performance of two systems were conducted under both the t-test using the predicted probabilities and McNemar's test using the binary predictions. Under both tests, the predictions from the TopicDecisionLSTM and the DynamicSpeakerModel are highly signification ( p < . 001 ). Predictions from UtteranceAE + LSTM and DynamicSpeakerModel are also significantly different based on both tests ( p < . 001 ). First, we manually inspect the predictions from the TopicDecisionLSTM and DynamicSpeakerModel used in 3.4 and the static baseline TopicPrior in 3.3. Compared with TopicPrior, we find that TopicDecisionLSTM is able to utilize the semantic relatedness between neighboring topics and corresponding user decisions. For example, Elon Musk (the CEO) is likely to be rejected if Tesla (the company) has been rejected earlier, though both are popular topics with high acceptance rates. In addition, it seems that the DynamicSpeakerModel is able to make use of user reactions. In the anecdotal example illustrated in Table 4, the user accepts the topic Arnold Schwarzenegger which is correctly predicted by both TopicDecisionLSTM and DynamicSpeakerModel, but only the DynamicSpeakerModel correctly predicts the rejection of politics later. We then analyze what language features are learned by latent modes in our dynamic speaker model. For each mode, we extract top utterances sorted by their association scores as computed in Bot : Do you like the actor Arnold Schwarzenegger? (1). Examples from the most representative modes are provided in Appendix A. In brief, we find two separate modes related to positive and negative reactions; other modes correspond to classes of dialog acts, such as yes/no answers, topic requests and conversation-closing. Within topic request modes, some involve short topic phrases (e.g.,  holidays ) while others use complete requests (e.g.  can we talk about cats ). Along this line, some modes are associated with relatively terse users and others with talkative users. These findings indicate that our model cpatures various user characteristics that might be useful for predicting their interaction preferences. Dialog act analysis is widely used for conversations, which identifies the illocutionary force of a speaker's utterance following the speech act theory (Austin, 1975; Searle, 1969). In this section, we apply the proposed dynamic speaker model to the dialog act classification task. We use the Switchboard Dialog Act Corpus (SwDA), which has dialog act annotations on two-party human-human speech conversations (Juraf-sky et al., 1997; Stolcke et al., 2000). In total, there are 1155 open-domain conversations with manual transcripts. Following recent work, we use 1115 conversations for training, 19 for testing, and the rest 21 for development. 3 The original fine-grained dialog act labels are mapped to 42 3 The training and test split files are downloaded from https://web.stanford.edu/jurafsky/ws97/ . classes. 4 For this set of experiments, we use the golden segmentation and manual transcripts provided in the dataset. Motivated by the recent success of unsupervised models (Peters et al., 2018; Devlin et al., 2019), we also study whether the dynamic speaker model can benefit from training on external unlabelled data. Thus, we use speech transcripts from 5850 conversations from the Fisher English Training Speech Part 1 Transcripts (Cieri et al., 2004), which (like Switchboard) consists of two-party human-to-human telephone conversations but without annotations for dialog acts. We use an attention-based LSTM tagging model for the dialog act classification. As shown in Fig. 2, the tagging LSTM is stacked on two speaker state trackers. Note the two trackers share the same parameters as well as the underlying latent mode analyzer and speaker language predictor. They generate speaker embeddings by tracking corresponding speakers separately. Let  ( t ) and  ( t ) denote the mappings from the global turn index t to the speaker-specific turn indices for speaker A and speaker B, respectively. The mapping returns a null value if the turn t is not associated with the corresponding speaker. The speaker state vectors are used as the input to the tagging LSTM for corresponding turns, i.e., x t = I ( h A ( t ) , h B ( t ) ) where I (  ,  ) is a switcher that chooses h A  ( t ) or h B  ( t ) depending on whether  ( t ) 4 Dialog act labels are mapped using scripts from http://compprag.christopherpotts.net/swda.html . Utterances labelled as segment are merged with corresponding previous utterance by the same speaker. and  ( t ) return a non-null value. The tagging LSTM also maintains a dictionary of L dialog act vectors g 1 , . . . , g L . The dialog act probabilities y t  RL at turn t are computed using the dot-product attention mechanism, i.e., y t = f ( z t , [ g 1 , . . . , g L ]) , where f (  ,  ) is defined as in (1), and z t is the hidden state vector of the LSTM. The tagging LSTM computes hidden states as z t +1 = g DA (cid:0) r DA ( g t , x t +1 ) , z t (cid:1) where  g t = (cid:80) Ll =1 y t,l g l , g DA (  ,  ) is the LSTM function, and r DA (  ,  ) is a linear function with learnable parameters. In this way, both the history dialog act predictions and the utterance information are encoded in the hidden states. The training objective of the tagging LSTM is the sum of the cross-entropy between the dialog act label and the probabilities y t at each turn. The training configuration is the same as the topic decision classifier described in 3.2. We tune the size of hidden states z t and dialog act embeddings g l from { 64 , 128 } with arbitrary combinations, and vary the number of LSTM hidden layers from { 1 , 2 } . The best model is selected according to the development set accuracy. In our experiments, we compare three settings for using the dynamic speaker model. In the pre-train setting, the dynamic speaker model is trained on the SwDA data without the dialog act labels. We then freeze the model when training the tagging LSTM. In contrast, in the pretrain + fine-tune setting, the dynamic speaker model is fine-tuned together with the tagging LSTM. Finally, in the pre-train w/Fisher + fine-tune setting, the dynamic speaker model is pre-trained on the combination of SwDA and Fisher datasets, and then fine-tuned together with the tagging LSTM on the SwDA dataset. For all three settings, we use the same vocabulary V of size 21K which combines all tokens from the SwDA training set and those appearing at least 5 time in the Fisher corpus. We compare our results to best published results. In (Kalchbrenner and Blunsom, 2013), a convolutional neural network (CNN) is used to encode utterances. A recurrent neural network (RNN) is then applied on top of the CNN to encode both utterances and speaker label information for predicting the dialog acts. Ji et al. (2016) propose a discourse-aware RNN LM by treating Model Acc (%) (Kalchbrenner and Blunsom, 2013) 73.9 (Tran et al., 2017a) 74.2 (Tran et al., 2017b) 74.5 (Tran et al., 2017c) 75.6 (Ji et al., 2016) 77.0 pre-train 75.6 pre-train + fine-tune 77.2 pre-train w/ Fisher + fine-tune 78.6  Table 5: Test set accuracy for SwDA dialog act classification. the dialog act as a conditional variable to the LM. Tran et al. (2017a,b,c) focus on building hierarchies of RNNs to model the dialog context using previous utterances or dialog act predictions. Results from (Lee and Dernoncourt, 2016) and (Liu et al., 2017) are not directly comparable due to different experiment settings. Experiment results are summarized in Table 5. Our pre-train setting performs on par with previous state-of-the-art supervised models except (Ji et al., 2016). Fine-tuning significantly improves the performance and allows the model to achieve a similar accuracy as (Ji et al., 2016). The best result is achieved by pre-training the dynamic speaker model with both SwDA and Fisher datasets. The improvement of pre-train w/ Fisher + fine-tune is statistically significant over pre-train + fine-tune based on McNemar's test ( p < . 001) . This illustrates the advantage of the unsupervised learning approach for the proposed model as it can exploit a large amount of unlabelled data. We analyze the latent modes learned on SwDA using the same approach as in 3.5. Again, specific examples are included in Appendix A. Overall, there are several modes corresponding to coarse-grained dialog acts, such as statements, questions, agreement, backchannel and conversation-closing. Many modes characterize statements, probably due to their high relative frequency in the corpus. Among the statement modes, there are two distinct groups, one containing multiple filled pauses, such as uh, you know, well , and the other one with because -clauses. The fact that coarse-grained dialog act information is partly encoded in the modes may be helping with recognizing the dialog act. In addition, we use the speaker gender information available in the SwDA data to determine whether the latent modes in the dynamic speaker model pick up gender-related language variation. Specific examples and statistics are included in Appendix B. The Cohen-d score (Cohen, 1988) is used to measure the strength of the difference between association score distributions of male vs. female utterances for individual modes. Based on the Cohen-d score, we identified two modes that have a strong association with male speakers, and two with female speakers. All have significantly different ( p < 0 . 001 ) distributions of association scores for female vs. male speakers using Mann-Whitney U test. In the top associated utterances for the male modes, we find utterances with several filled pauses, which has been found to be indicative of male speakers in previous work on Switchboard (Boulis and Ostendorf, 2005). The female modes are mostly agreement, acknowledgement and backchannel, which aligns with a popular sociolinguistic theory that females are more responsive (Coates, 1998). Based on this, we conclude that some speaker gender language variations are indeed captured by the learned modes. As reviewed by Zukerman and Litman (2001), user modeling for conversational systems has a long history. The research can be tracked back to the GRUNDY system (Rich, 1979) which categorizes users in terms of hand-crafted sets of user properties for book recommendation. Other systems have focused on different aspects of users, e.g., the expertise level of the user in a specific domain (Chin, 1986; Sleeman, 1985; Paris, 1987; Hovy, 1987), the user's intent and plan (Allen and Perrault, 1980; Carberry, 1983; Litman, 1986; Moore and Paris, 1992), and the user's personality (Mairesse and Walker, 2006; DeVault et al., 2014; Fung et al., 2016; Fang et al., 2017). User modeling has also been employed for personalized topic suggestion in recent Alexa Prize socialbots, using a pre-defined mapping between personality types and topics (Fang et al., 2017), or a conditional random field sequence model with hand-crafted user and context features (Ahmadvand et al., 2018). Modeling speakers with continuous embeddings for neural conversation models is studied in (Li et al., 2016), where the model directly learns a dictionary of speaker embeddings. Our unsupervised dynamic speaker model differs from previous work in that we build speaker embeddings as a weighted combination of latent modes with weights computed based on the utterance. Thus, the model can construct embeddings for any new users and dynamically update the embeddings as the conversation evolves. Speaker language variances have been analyzed by previous work and incorporated in NLP models. Preotiuc-Pietro et al. (2016) and Jo-hannsen et al. (2015) find that speaker-level language variance affects lexical choices and even syntactic structure based on psycholinguistic hypotheses. Speaker demographics are used to improve both low-level tasks such as part-of-speech tagging (Hovy and Sgaard, 2015) and high-level applications such as sentiment analysis (Volkova et al., 2013) and machine translation (Mirkin et al., 2015). Lynn et al. (2017) introduce a continuous adaptation method to include user age, gender, personality traits and language features for personalizing several supervised NLP models. Different from previous work, we study the use of speaker embeddings learned from utterances in an unsupervised fashion and analyze the possible interpretability of the latent modes. In this paper, we address the problem of modeling speakers from their language using an unsupervised approach. A dynamic speaker model is proposed to learn speaker embeddings that are updated as the conversation evolves. The model achieves promising results on two representative tasks in dialogs: user topic decision prediction in human-socialbot conversations and dialog act classification in human-human conversations. In particular, we demonstrate that the model can benefit from unlabelled data in the dialog act classification task, where we achieve the state-of-the-art results. Finally, we carry out analysis on the learned latent modes on both tasks, and find cues that suggest the model captures speaker characteristics such as intent, speaking style, and gender. For future work, it could be interesting to explore guiding some latent modes with a few examples to pick up specific user features such as personality traits. We thank the anonymous reviewers for their helpful feedback. We also thank Trang Tran for her feedback on the paper. This research is supported by Amazon Alexa Fellowship and Tencent AI Lab Rhino-Bird Gift Fund. The conclusions and findings are those of the authors and do not necessarily reflect the views of sponsors.
abstain abstain method abstain abstain abstain abstain abstain abstain other method abstain abstain abstain abstain abstain abstain abstain objective objective abstain abstain method abstain abstain abstain abstain abstain abstain abstain method method abstain method abstain abstain method abstain abstain abstain method abstain abstain method method abstain abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain other abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain method abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method method abstain abstain method abstain method abstain abstain method abstain method other abstain method abstain method method abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain result abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain method abstain method abstain abstain abstain abstain other other other other other objective other other other other other method method abstain abstain objective result abstain other other other other