When intelligent agents communicate to accomplish shared goals, how do these goals shape the agents' language? We study the dynamics of learning in latent language policies (LLPs), in which instructor agents generate natural-language subgoal descriptions and executor agents map these descriptions to low-level actions. LLPs can solve challenging long-horizon reinforcement learning problems and provide a rich model for studying task-oriented language use. But previous work has found that LLP training is prone to semantic drift (use of messages in ways inconsistent with their original natural language mean-ings). Here, we demonstrate theoretically and empirically that multitask training is an effective counter to this problem: we prove that multitask training eliminates semantic drift in a well-studied family of signaling games, and show that multitask training of neural LLPs in a complex strategy game reduces drift and while improving sample efficiency. A major goal in the study of artificial and natural intelligence is to understand how language can scaffold more general problem-solving skills (e.g. Spelke, 2017), and how these skills in turn shape language itself (e.g. Gibson et al., 2017). In NLP and machine learning, latent language policies (LLPs; Andreas et al., 2018) provide a standard framework for studying these questions. An LLP consists of instructor and executor subpolicies: the instructor generates natural language messages (e.g. high-level commands or subgoals), and the executor maps these messages to sequences of low-level actions (Fig. 1). LLPs have been used to construct interactive agents capable of complex reasoning (e.g. programming by demonstration) and planning over long horizons (e.g. in strategy games; Hu et al., 2019). They promise an effective and interpretable interface between planning and control. However, they present a number of challenges for training. As LLPs employ a human-specified space of high-level commands, they must be initialized with human supervision, typically obtained by pretraining the executor. On its own, this training paradigm restricts the quality of the learned executor policy to that exhibited in (possibly suboptimal) human supervision. For tasks like the real-time strategy game depicted in Fig. 1, we would like to study LLPs trained via reinforcement learning (RL) , jointly learning from a downstream reward signal, and optimizing both instructors and executors for task success rather than fidelity to human teachers. Training LLPs via RL has proven difficult. Past work has identified two main challenges: primarily, the LLP-specific problem of semantic drift , in which agents come to deploy messages in ways inconsistent with their original (natural language) meanings (Lewis et al., 2017; Lee et al., 2019); secondarily, the general problem of sample inef-ficiency in RL algorithms (Kakade et al., 2003; Brunskill and Li, 2013). Model-free deep RL is particularly notorious for requiring enormous amounts of interaction with the environment (Munos et al., 2016; Mnih et al., 2013b). For LLPs to meet their promise as flexible, controllable, and understandable tools for deep learning, better approaches are needed to limit semantic drift and perhaps improve sample efficiency. While semantic change is a constant and well-documented feature of human languages (McMa-hon and April, 1994), (human) word meanings are on the whole remarkably stable relative to the rate of change in the tasks for which words are deployed (Karjus et al., 2020). In particular, disappearance of lexical items is mitigated by increased population size (Bromham et al., 2015) and increased frequency of use (Pagel et al., 2007). Drawing on these facts about stabilizing factors in human language, we hypothesize that training of machine learning models with latent language variables can be made more robust by incorporating a population of instructors with diverse communicative needs that exercise different parts of the lexicon. We describe a multitask LLP training scheme in which task-specific instructors communicate with a shared executor. We show that complex long-horizon LLPs can be effectively tuned via joint reinforcement learning of instructors and executors using multitask training :  Section 3 presents a formal analysis of LLP training as an iterated Lewis signalling game (Lewis, 1969). By modeling learning in this game as a dynamical system, we completely characterize a class of simple policies that are subject to semantic drift. We show that a particular multitask training scheme eliminates the set of initializations that undergo semantic drift. Section 4 evaluates the empirical effectiveness of multitask learning in a real-time strategy game featuring rich language, complex complex dynamics, and LLPs implemented with deep neural networks. Again, we show that multitask training reduces semantic drift (and improves sample efficiency) of LLPs in multiple game variants. Together, these results show that diverse shared goals and communicative needs can facilitate (and specifically stabilize) learning of communication strategies. Deep reinforcement learning (DRL) has recently made impressive progress on many challenging domains such as games (Mnih et al., 2013a; Silver et al., 2016), locomotion (Schulman et al., 2015) and dexterous manipulation tasks (Gu et al., 2016; Rajeswaran et al., 2017). However, even state-of-the-art approaches to reinforcement struggle with tasks involving complex goals, sparse rewards, and long time horizons. A variety of models and algorithms for hierarchical reinforcement learning have been proposed to address this challenge (Dayan and Hinton, 1993; Dietterich, 2000; Richard et al., 1999; Bacon et al., 2017) via supervised or unsupervised training of a fixed, discrete set of sub-policies. Language can express arbitrary goals, and has compositional structure that allows generalization across commands. Building on this intuition, several recent papers have explored hierarchical RL in which natural language is used to parameterize the space of high-level actions (Oh et al., 2017; Andreas et al., 2017; Shu et al., 2018; Jiang et al., 2019; Hu et al., 2019). While there are minor implementation differences between all these approaches, we will refer to them collectively as latent language policies (LLPs) . Like other hierarchical agents, an LLP consists of a pair of subpolicies: an instructor I ( m | o ) and an executor E ( a | m, o ) . An LLP takes actions by first sampling a string-valued message m  I from the instructor, and then an action a  E from the executor. For these messages to correspond to natural language , rather than arbitrary strings, policies need some source of information about what human language users think they mean. This is typically accomplished by pretraining executors via human demonstrations or reinforcement learning; here we focus on the ingredients of effective joint RL of instructors and executors. Reinforcement learning has been widely used to improve supervised language generation policies, particularly for dialogue (Li et al., 2016; Lewis et al., 2017), translation (Ranzato et al., 2015; Wu et al., 2016) and summarization (Stiennon et al., 2020). Here, we instead focus on models where language is a latent variable as part of a hierarchical policy for a non-linguistic task. As noted in Section 1, an observed shortcoming of reinforcement learning in all these settings is its susceptibility to semantic drift . In the literature on human language change (Blank, 1999), semantic drift refers to a variety of phenomena, including specific terms becoming more general, general terms becoming specific, and parts coming to refer to wholes. In machine learning, it refers broadly to the use of messages inconsistent with their natural language meanings in language-generation policies (Lazaridou et al., 2020). Lee et al. (2019) mitigate semantic drift in pivot-based machine translation by using visual grounding, whereas Lu et al. (2020) periodically update a student model on data generated by an RL teacher. Work in emergent communication has found that reinforcement learning tends not to learn policies with natural language-like properties (Kottur et al., 2017), although population-based training has been found to be helpful (Gupta et al., 2019). Most relatedly to our work, Lazaridou et al. (2020) train speaker-listener agents jointly in a visual referential communication task and introduce auxiliary loss functions for stabilizing training. Our work focuses on a more general setting where the interactions are temporally extended, have large action spaces and is partially observable. Agarwal et al. (2019) use populations of agents to reduce semantic drift in visual dialogue. We view the current paper's analysis of multitask learning as complementary to these approaches from the emergent communication literature; future work might consider ways of combining the two. A great deal of recent work in both RL (e.g. Jaderberg et al., 2016; Shelhamer et al., 2016) and language processing (e.g. Clark et al., 2019; Gu-rurangan et al., 2020) has observed that carefully designed training objectives can serve as a source of model-agnostic inductive bias. Our results bring these two lines of work together: multitask training improves the faithfulness and adaptability of learned language understanding models, even when optimizing for a downstream reward. We begin our analysis with the simple signaling game depicted in Fig. 2. In this game, one agent receives an observation, then sends a message to another agent, which then performs an action. Signaling games like this one are widely studied in NLP as models of reference resolution and language generation (Frank and Goodman, 2012). The instructorexecutor pair may together be viewed as the simplest LLP of the kind described in Section 2. Formally, a (2-observation, 2-message) Lewis signalling game is defined by:  a set of observations O = { o 1 , o 2 }  a set of messages M = { m 1 , m 2 }  a set of actions A = { a 1 , a 2 }  a reward function R : O  A  R The game is played between two agents: a instructor (with parameters  I ), which receives an observation and samples an observation-specific message from a distribution I ( m | o ;  I ) ; and a executor (with parameters  E ), which receives the instructor's message and uses it to sample an action from a distribution E ( a | m ;  E ) . The agents then receive a reward R ( o, a ) that depends on the observation and action but not on the message sent. This policy's expected reward is given by: (cid:88) o  O m  M a  A p ( o ) I ( m | o ;  I ) E ( a | m ;  E ) R ( o, a ) . Gradient ascent on Eq. (1) with respect to  I and  E (e.g. using a policy gradient algorithm; Williams, 1992) can be used to improve the expected reward obtained by an LLP. As an example, the right portion of Fig. 2 shows two reward functions R and R (cid:48) . In both, each observation is paired with a single action, and the executor must take the action corresponding to the observation to receive a positive reward. For R , two strategies obtain the optimal expected reward of 1: one in which I ( m 1 | (cid:78) ) = 1 and E ( red | m 1 ) = 1 , and one in which I ( m 1 | (cid:4) ) = 1 and E ( blue | m 1 ) = 1 . Almost every initialization of  E and  I (excluding a set of pooling equilibria ; see e.g. Huttegger et al., 2010) converges to one of these two strategies when agents are jointly trained to optimize Eq. (1). Semantic drift Suppose, as shown in Fig. 2, the messages m 1 and m 2 are not arbitrary symbols, but correspond to the natural language expressions m 1 = push red and m 2 = push blue . In this case, only of the policies described above corresponds to the semantics of natural languagenamely, the one in which E ( a 1 | m 1 ) = E ( red | push red ) = 1 . What is needed to ensure that a pair of agents playing converge to the natural language strategy? I ( m j | o i ;  I ) = (cid:40)  I i = j 1   I otherwise (2) E ( a j | m i ) = (cid:40)  E i = j 1   E otherwise (3) For the game depicted in Fig. 2, we would like to avoid any outcome in which, after training,  E = E ( red | push red ) < 12 . More generally, let us assume that we have an initial set of executor parameters that are possibly suboptimal but correspond to natural language semantics in the sense that E ( a | m i ;  (0) E ) > 12 if and only if the meaning of m is do a . In this case, we will say that a parameter initialization (  (0) I ,  (0) E ) undergoes executor semantic drift if, after training, any such E ( a | m i ;  E ) =  E < 12 . To analyze semantic drift in this game, we consider the final values of the parameters (  I ,  E ) when optimized from an initialization (  (0) I ,  (0) E ) . For the reward function R depicted in Fig. 2, we can perform gradient ascent on Eq. (1) with respect to  I and  E in this model by observing that: J  I =  E  1 2 J  E =  I  1 2 (4) By considering the limiting behavior of gradient ascent as step size goes to zero (a gradient flow ; see Appendix A), it is possible to give a closed-form expression for the value of these parameters as a function of time: Proposition 1. Suppose  (0) E +  (0) I < 1 . Then two agents optimizing Eq. (1) via Eq. (4) undergo semantic drift (converging to  E = 0 ). Proof is given in Appendix A. Note in particular that semantic drift will occur whenever  (0) I < 1   (0) E , which can occur even assuming a well-initialized executor with  E > 12 . Fig. 5 in the appendix provides a visualization of learning dynamics and these drift-susceptible initializations. However, we will next show that this drift can be eliminated via multitask training. Multitask signaling games Consider a multitask version of this game with the two reward functions R and R (cid:48) depicted in Fig. 2. As discussed in the introduction and depicted in Fig. 1, our approach to multitask training focuses on sharing a single executor E ( a | m ;  E ) between multiple task-specific instructors, here I ( m | o ;  I 1 ) and I ( m | o ;  I 2 ) , both parameterized as in Eq. (2). As above, we train (  I 1 ,  I 2 ,  E ) jointly to optimize: (cid:88) o,m,a p ( o ) I ( m | o ;  I 1 ) E ( a | m ;  E ) R ( o, a ) + (cid:88) o,m,a p ( o ) I ( m | o ;  I 2 ) E ( a | m ;  E ) R (cid:48) ( o, a ) (5) We assume that the two instructors share the same initialization, with  (0) I 1 =  (0) I 2 =  (0) I . In this case, the following is true: Proposition 2. Suppose  (0) E > 12 and  (0) I 1 =  (0) I 2 . Then three agents optimizing Eq. (5) via its gradient flow do not undergo semantic drift. In fact, the eventual executor parameter  ( t ) E is independent of the initial speaker parameters  (0) I 1 and  (0) I 2 . Proof is again given in Appendix A. It is important to emphasize that these results concern the simplest possible policies for the signaling games considered here: agents with a single parameter which already bake in the assumption that different signals should trigger different behaviors. We leave generalization of this formal analysis to general signaling games with more complex agents and message spaces for future work, noting that at least in this simple casewe have succeeded in constructing a concrete multitask objective that reduces (indeed eliminates) the set of initial model parameters subject to semantic drift. We next verify whether this result extends to the complex LLP-learning tasks discussed in Section 2. Our focus in this section is the MINIRTS environment of Hu et al. (2019) (depicted in Fig. 1), in which agents must build and control an army of units like archers, spearmen, swordman, cavalry, and dragons, each with specialized abilities, with the goal of destroying the opponent's town center. Using this game, Hu et al. (2019) crowdsourced a dataset of high-level instructions (like attack with dragon and send idle peasant to mine ) paired with low-level action sequences (Fig. 1). They showed that an LLP trained on this supervised data via behavior cloning significantly outperformed a flat policy trained with imitation learning directly on low-level action sequences. Here we investigate (1) whether these policy-cloned LLP can be further improved via reinforcement learning directly on a sparse winloss signal from the game, (2) whether we can improve sample efficiency during reinforcement learning by jointly training executor models on multiple game variants simultaneously through multitask learning, and (3) whether semantic drift can be avoided during multi-task training. Below, Section 4.1, Section 4.2 and Section 4.3 provide more detail about the task, model, and training procedure. Section 4.4 reports experimental results. MINIRTS is a partially-observable real-time strategy game environment, in which the actions of a large number of units must be coordinated on long time scales to defeat an opposing player. In a typical episode, a player must use its initial units to gather resources, use resources to build specialized structures for producing other units, and finally deploy these units to attack the opposing player's base. This involves challenging problems in both low-level tactics (controlling the placement of individual units for resource-gathering and combat) and high-level strategy (deciding which unit types to build, and when to deploy them). MINIRTS additionally features a dataset collected from pairs of humans playing collaboratively against rule-based opponents. One human, the instructor , designs high-level strategies and describes them in natural language. The other human, the executor observes the environment state as well as the natural language strategy descriptions from the instructor and selects appropriate low-level actions. The dataset consists of 5,392 games, with a total of 76,045 (instruction, execution) pairs. Hu et al. (2019) use the labeled data to train an LLP for the MINIRTS environment. Our experiments use the same model architecture (Fig. 3), which we briefly review here; see the original for details. Observation encoder The instructor and executor models condition on a fixed-sized representation of the current game state which are constructed using different encoders for various aspects of the game state (Fig. 3):  Spatial input encoder : The spatial information of the map is encoded using a convolutional neural network. Non-spatial input encoder : The non-spatial attributes and internal state of game objects are encoded using a simple MLP. These include attributes like the number of enemy units, the agent's units, and resource locations. Instruction encoder : The current instruction is encoded with a recurrent neural network. Auxiliary encoder : Global variables, such as the total number of resources collected, are additionally encoded with an MLP. Instructor model The instructor takes in the game state from the observation encoder and produces instructions. The 500 instructions appearing most frequently in the training set are encoded with an RNN into a fixed-sized vector. The score for each instruction is proportional to its dot product with the game state encoding. This instructor model achieved the best performance on several metrics in the original work (Hu et al., 2019). By restricting the instructor to the most frequent 500 well-formed natural language strings, we are able to focus our attention on semantic drift. A generative model free to generate arbitrary strings might also be subject to syntactic drift. Executor model The executor predicts an action for every unit controlled by the agent based on of the current observation as encoded by the various encoders. The executor then predicts an action { } dim { dim { dim { dim # our units } based on these features. In particular, for each unit, it predicts one of the 7 action types (IDLE , CONTINUE , GATHER , ATTACK , TRAINUNIT , BUILDBUILDING , MOVE ), an action target location (for the MOVE , ATTACK , GATHER and BUILDBUILDING actions) and a unit type (for the TRAINUNIT and BUILDBUILDING actions). Taking the product of the factorized action and location arguments across all units, the action space for the executor can be enormous, with as many as 10 24 distinct actions available on a single turn. As mentioned above, the original work of Hu et al. (2019) (and other work on learning LLPs) focused on behavior cloning or independent supervision of the instructor and executor . In the current paper, we are interested in the the dynamics of joint reinforcement learning of LLPs in both singleand multitask settings. Experiments in Section 4.4 make use of models trained with all three strategies. Rule-based opponent pool Agents are trained against a similar pool of rule-based bots (see Hu et al., 2019) used to collect the human data. These bots follows a randomly selected, unit-specific strategy, building a fixed number of SWORDMEN , SPEARMEN , CAVALRY , ARCHERS or DRAGONS and attacking as soon as they are constructed. Behavior cloning Behavior-cloned models are trained using the supervised MINIRTS dataset. Given a collection of game observations o , each annotated with a high-level action m and a low-level action a , we maximize: max  I , E (cid:88) o,m,a (cid:2) log I ( m | o ;  I ) + log E ( a | m, o ;  E ) (cid:3) . During training, one frame is taken from every K frames to form the supervised learning dataset. To preserve unit level actions for the executor training, all actions that happen in [ tK, ( t + 1) K ) frames are stacked onto the tK th frame. Reinforcement learning To train agents via reinforcement learning, we initialize them with the behavior cloning objective in Eq. (6) to provide an initial, human-meaningful grounding of message semantics (analogous to the initialization of the executor parameter  (0) E in Section 3). We then fine-tune them on game success, providing a sparse reward of 1 when agents win the game, -1 when they lose or draw the game. As in Section 3, learned agents are trained on the game reward, using a proximal policy optimization (PPO) (Schulman et al., 2017) objective to optimize the expected reward: E ( s,a )  ( I,E ) R ( s, a ) . (7) Multi-task RL The original game of Hu et al. (2019) is defined by a set of attack multipliers : the aforementioned rock-paper-scissors dynamic arises because spearmen are especially effective against cavalry, archers against dragons, etc. To create alternative tasks in the MiniRTS environment, we create alternative versions of the game featuring different multipliers: e.g. making dragons invulnerable to archers or cavalry extra-effective against swordsmen. Table 1 shows these multipliers for the original rule, and a set of game variants with different multipliers are described in Appendix D. These variants are labeled BJ in the experiments that follow. Multiplier changes have significant effects on the optimal high-level strategy, affecting both which units are most effective overall, and how players should respond to opponents' choices. As in Section 3, we perform multitask LLP training in the MINIRTS environment by jointly optimizing expected reward across multiple game variants at once, assigning each variant its own set of instructor parameters  I (initialized to the same value) but sharing a single set of executor parameters  E across all contexts. The training pseudo-code can be found in Appendix C. 4.4 Experiments Unlike in the signaling game considered in Section 3, MINIRTS is complex, and we cannot take for granted that reinforcement learning of LLPs (with either ordinary or multitask objectives) will converge to an improved good solution at all. We thus begin with an analysis of policy performance and sample efficiency, then conclude this section with an analysis of semantic drift. (Model training details can be found in Appendix B.) 4.4.1 Evaluating performance and sample efficiency To evaluate policy quality and sample complexity, we compare the final win rate (against the fixed pool of rule-based agents) for the policy-cloned (BC), RL-tuned (RL joint ), and multitask-RL-tuned (RL multi ) agents described above. We perform this evaluation for multiple game configurations: original , with the same rules used by Hu et al. (2019) for human data collection and evaluation, and 3 alternative variants ( variant G , variant H , variant J ) , in which the relative strengths of various units has been modified (see Appendix D). We train 4 separate (RL joint ) agents corresponding to each of the environments and 2 (RL multi ) agents. Following D'Eramo et al. (2019), we provide both training strategies with a fixed budget of training experience across environments : both RL joint and RL multi have been trained on the same number of game episodes per training environment. We also present the win rates for RL joint and RL multi , when trained on 3  Attack multiplier Unit name Swordman Spearman Cavalry Archer Dragon SWORDMAN 1.0 1.5 0.5 1.0 0.0 SPEARMAN 0.5 1.0 1.5 1.0 0.0 CAVALRY 1.5 0.5 1.0 1.0 0.0 ARCHER 0.5 0.5 0.5 0.5 2.0 DRAGON 1.0 1.0 1.0 0.5 1.0 Table 1: Attack multipliers for the original game rules. For example, cavalry are extra-effective against swordsmen (1.5 in Swordsman col.); only archers and dragons can attack dragons (nonzero entries in Dragon col.). See Appendix D for other game variants' multipliers. more episodes per environment. Results are shown in Table 2. Both RL fine-tuning strategies allow the policy to significantly improve over the behavior-cloned initializer, showing that effective reinforcement learning of LLPs is possible in MINIRTS. In most environments, performance of the model fine-tuned with the multitask training is higher than ordinary joint RL training. When RL joint is provided extra training budget, it sometimes surpasses the performance of RL multi model with standard number of episodes. However, when RL multi is also given the extra training budget, it performs better in all but one environment. At a high level, these results indicate that multitask training of LLPs can be applied at small (and in some cases no) cost in accuracy and significantly less per-environment training cost. 4.4.2 Evaluating semantic drift Next, we consider the second question from the introduction: outside of performance effects, does multitask training with populations of instructors reduce semantic drift in executors? We present two Training Evaluation Win rate strategy environment (standard) (3  training) BC original 30.3 RL joint [orig.] 65.7 86.9 RL multi [orig., B, C] 76.5 90.6 BC variant G 11.6 RL joint [G] 73.0 74.1 RL multi [G, H, J] 75.7 77.6 BC variant H 26.2 RL joint [H] 82.2 91.4 RL multi [G, H, J] 79.4 83.5 BC 14.6 RL joint [J] variant J 87.2 93.0 RL multi [G, H, J] 91.2 93.7 Table 2: Evaluation of policy quality in MINIRTS. Semantic drift In MINIRTS, executor semantic drift occurs when the executor performs actions that are not consistent with the instruction produced by the instructor. ( i.e., create spearman instruction produced by the instructor leads to the executor producing swordman instead). In particular, this occurs in RL joint because the instructor and executor can co-adapt to new semantics during exploration as they are only trained to win the game. Agent interoperability First, we evaluate the robustness of executor policies to alternative choices of instructors. Specifically, we pair each RL-trained executor with an instructor trained either via behavior cloning (and thus guaranteed to implement the human annotators' semantics) or fine-tuning (RL instr ) on a different game variant from the executor (and thus not co-adapted with it). Intuitively, to succeed at this task, executors must follow messages produced by the instructors trained in that domain. Executors that have undergone less semantic drift should perform better when paired with these different instructors. Results are shown in Table 3; here, it can be seen that multitask learning matches or exceeds the performance of single-task training on this evaluation of semantic drift in all rule variants studied, even when RL joint is provided additional training budget. As evidence that performance comes from instructorexecutor pairs, Instructor Executor Eval. rather than executors alone, using a random coach paired with RL multi [orig., B, C] on variant D gives 33.2% accuracy. Additionally, when RL multi [orig., B, C] is paired with a coach from a different variant, we get an accuracy of just 41% on variant D. Low-level action semantics As an alternative means of gaining insight into learned behaviors, we can directly inspect the correspondence between instructor messages and executor actions. We do this by uniformly sampling messages from a random instructor, then feeding them to the RL multi and RL joint executors and observing their choice of low-level actions a . We then restrict these these ( m, a ) pairs to those in which (1) the text of m includes one of the words create, build, train or make and the name of a unit ( peasant , spearman , etc.) and (2) a is a TRAINUNIT action for any unit. We then compute the empirical probability P ( unit 1  a | unit 2  m ) as shown in Fig. 4. If there is semantic drift, we expect to observe nonzero probability on the off-diagonal entries (the executor is building units different from those it is instructed to build). RL multi places less probability mass on the off-diagonal entries compared to RL joint , consistent with less semantic drift. In Fig. 4, one can also note that some word meanings change more than others. We hypothesize that, this is because like in natural languages, environmental pressures cause the meanings of some words to change at a greater rate than others. In this case, the dynamics of the game makes the spearman unit slightly stronger than the swordman unit overall. This results in unexpectedly good performance for players who accidentally misinterpret swordman as spearman . Therefore, this creates pressure for the conventional meaning of swordman to shift more than other units. Taken together, these two evaluation results show that, when fine-tuning a policy initialized via imitation learning on the same objective, ordinary RL can be quite effective: the resulting executor model performs well even when paired with other instructors. But as in Section 3, multitask training is even more helpful, especially by reducing semantic drift in both familiar and new environments. We have presented a theoretical and empirical analysis of semantic drift and sample efficiency in multitask reinforcement learning of latent language policies (LLPs). In a Lewis signaling game, we Figure 4: Messageaction drift in MINIRTS. proved that multitask training can completely eliminate semantic drift. In a two-player real-time strategy game, we showed that multitask training is effective at mitigating semantic drift, improves the quality of learned policies and is sample efficient. Future work might integrate these results with other forms of population-based training (like those proposed by Gupta et al. (2019) for reference games) and explore other environmental factors affecting dynamics of language change in populations of learned agents. We thank Hengyuan Hu for assistance in reproducing the original work and MIT Supercloud for compute resources. We also thank Eric Chu, Alana Marzoev, Ekin Akyrek and Debby Clymer for feedback and proof-reading.
abstain method abstain abstain objective abstain abstain abstain abstain abstain abstain abstain abstain method abstain other abstain abstain abstain abstain objective abstain result abstain result objective result abstain other other other other other abstain other other other method other method other other other other other abstain objective other method other abstain method abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain method method other abstain abstain abstain abstain abstain abstain method abstain method abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain abstain other abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain method abstain abstain abstain abstain abstain abstain abstain abstain abstain method abstain abstain result abstain other other