Original: E MERGENT C OMMUNICATION WITH A TTENTION
Revised: MERGENT C OMMUNICATION WITH A TTENTION

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: To develop computational agents thatcan better communicate with others using their own emergent language, we endow the agents with an ability to focus their attention on particular concepts in the environment.
Revised: To develop computational agents that better communicates using their own emergent language, we endow the agents with an ability to focus their attention on particular concepts in the environment.

Original: Humans often understand a thing or scene as a composite of concepts and those concepts are further mapped onto words.
Revised: Humans often understand a thing or scene as a composite of concepts and those concepts are further mapped onto words.

Original: We implement this intuition as attention mechanisms in Speaker and Listener agents in a referential game and show attention leads to more compositional and interpretable emergent language.
Revised: We implement this intuition as attention mechanisms in Speaker and Listener agents in a referential game and show attention leads to more compositional and interpretable emergent language.

Original: We also demonstrate how attention helps us understand the learned communication protocol by investigating the attention weights associated with each message symbol and the alignment of attention weights between Speaker and Listener agents.
Revised: We also demonstrate how attention helps us understand the learned communication protocol by investigating the attention weights associated with each message symbol and the alignment of attention weights between Speaker and Listener agents.

Original: Overall, our results suggest that attention is a promising mechanism for developing more human-like emergent language.
Revised: Overall, our results suggest that attention is a promising mechanism for developing more human-like emergent language.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: We endow computational agents with an ability to focus their attention on a particular concept in the environment and communicatethe concept using emergent language.
Revised: We endow computational agents with an ability to focus their attention on a particular concept in the environment and communicate using emergent language.

Original: Emergent language refers to the communication protocol based on discrete symbols developed bycomputational agents to achieve a specific taskgoal (Nowak & Krakauer, 1999; Lazaridou et al., 2017).
Revised: Emergent language refers to the communication protocol based on discrete symbols developed by agents to solve a specific task (Nowak & Krakauer, 1999; Lazaridou et al., 2017).

Original: One important goal in the study of emergent language is clarifying conditions that lead to more compositionalemergent languages.
Revised: One important goal in the study of emergent language is clarifying conditions that lead to more compositional languages.

Original: Seeking compositionality provides insights into the origin of the compositional natures of human language and helps develop efficient communication protocols in multi-agent systems that are interpretableand easily controllable by humans.
Revised: Seeking compositionality provides insights into the origin of the compositional natures of human language and helps develop efficient communication protocols in multi-agent systems that are interpretable by humans.

Original: Much recent work studies emergent language with generic deep agents (Lazaridou & Baroni, 2020) with minimum assumptions on the inductive bias of the model architecture.
Revised: Much recent work studies emergent language with generic deep agents (Lazaridou & Baroni, 2020) with minimum assumptions on the inductive bias of the model architecture.

Original: For example, a typical speaker agent encodes information into a single fixed-length vector to initialize the hidden state of a RNN decoder and generate symbols (Lazaridou et al., 2017; Mordatch & Abbeel, 2018; Ren et al., 2020).
Revised: For example, a typical speaker agent encodes information into a single fixed-length vector to initialize the hidden state of a RNN decoder and generate symbols (Lazaridou et al., 2017; Mordatch & Abbeel, 2018; Ren et al., 2020).

Original: Only a few studies have explored some architectural variations (Słowik et al., 2020) to improve the compositionality of emergent language, and there remains much to be discussed about the effects of the inductive bias provided by different architectures.
Revised: Only a few studies have explored some architectural variations (Słowik et al., 2020) to improve the compositionality of emergent language, and there remains much to be discussed about the effects of the inductive bias provided by different architectures.

Original: We posit that towards more human-like emergent language we need to explore other modeling choices that reflect the human cognitive process.
Revised: We posit that towards more human-like emergent language we need to explore other modeling choices that reflect the human cognitive process.

Original: In this study, we focus on the attention mechanism.
Revised: In this study, we focus on the attention mechanism.

Original: Attention is one of the most successful neural network architectures (Bahdanau et al., 2015;
Revised: Attention is one of the most successful neural network architectures (Bahdanau et al., 2015;

Original: Xu et al., 2015; Vaswani et al., 2017) that have an analogy in psychology (Lindsay, 2020).
Revised: Xu et al., 2015; Vaswani et al., 2017) that have an analogy in psychology (Lindsay, 2020).

Original: The conceptual core of attention is an adaptive control of limited resources, and we hypothesize that this creates pressure for learning more compositional emergent languages.
Revised: The conceptual core of attention is an adaptive control of limited resources, and we hypothesize that this creates pressure for learning more compositional emergent languages.

Original: Compositionality entails a whole consisting of subparts.
Revised: Compositionality entails a whole consisting of subparts.

Original: Attention allows the agents to dynamically highlight different subparts of an object when producing/understanding each symbol, which potentially results in clear associations between the object attributes and symbols.
Revised: Attention allows the agents to dynamically highlight different subparts of an object when producing/understanding each symbol, which potentially results in clear associations between the object attributes and symbols.

Original: Another reason to explore the attention mechanism is its interpretability.
Revised: Another reason to explore the attention mechanism is its interpretability.

Original: Emergent language is optimized for task success and the learned communication protocol often results in counter-intuitive and opaque encoding (Bouchacourt & Baroni, 2018).
Revised: Emergent language is optimized for task success and the learned communication protocol often results in counter-intuitive and opaque encoding (Bouchacourt & Baroni, 2018).

Original: Several metrics have been proposed to measure specific characteristics of emergent language (Brighton & Kirby, 2006; Lowe et al., 2019) but these metrics provide rather a holistic view of emergent language and do not tell us a fine-grained view of what each symbol is meant for or understood as.
Revised: Several metrics have been proposed to measure specific characteristics of emergent language (Brighton & Kirby, 2006; Lowe et al., 2019) but these metrics provide rather a holistic view of emergent language and do not tell us a fine-grained view of what each symbol is meant for or understood as.

Original: Attention weights, on the other hand, have been shown to provide insights into the basis of the network’s prediction (Bahdanau et al., 2015;Xu et al.,
Revised: Attention weights, on the other hand, have been shown to provide insights into the basis of the network’s prediction (Bahdanau et al., 2015;

Original: ; Yang et al., 2016).
Revised: Xu et al., 2015; Yang et al., 2016).

Original:  attention  the process  symbol production/comprehension will allow us to inspect the meaning of each symbol in the messages.
Revised: Incorporating attention in the process of symbol production/comprehension will allow us to inspect the meaning of each symbol in the messages.

Original: In this paper, we test attention agents with the referential game (Lewis, 1969; Lazaridou et al., 2017), which involves two agents: Speaker and Listener .
Revised: In this paper, we test attention agents with the referential game (Lewis, 1969; Lazaridou et al., 2017), which involves two agents: Speaker and Listener .

Original: The goal of the game is to convey the type of object that Speaker sees to Listener.
Revised: The goal of the game is to convey the type of object that Speaker sees to Listener.

Original: We conduct extensive experiments with two types of  environments:one-hot vector games where the referents are given in the form of binary vectors andmore realistic settings where the referents are pixel images.
Revised: We conduct extensive experiments with two types of agent architectures, LSTM and Transformer, and two types of environments: the one-hot game and the Fashion-MNIST game.

Original: We compare our attention agents against  non-attention counterparts with various metrics of compositionality and show that adding attention mechanisms with disentangled inputs to either/both Speaker or/and Listener helps develop a more compositional language.
Revised: We compare the attention agents against their non-attention counterparts to show that adding attention mechanisms with disentangled inputs to either/both Speaker or/and Listener helps develop a more compositional language.

Original: We also analyze the attention weights and explore how they can help us understand the learned language.
Revised: We also analyze the attention weights and explore how they can help us understand the learned language.

Original: After we confirm that the agents learn to selectively attend to the inputs, we visualize the learned symbol-concept mapping and demonstrate how the emergent language can deviate from human language and, with experiments with pixel images, how the emergent language can be affected by the visual similarity of referents.
Revised: We visualize the learned symbolconcept mapping and demonstrate how the emergent language can deviate from human language and, with experiments with pixel images, how the emergent language can be affected by the visual similarity of referents.

Original: We also investigate the potential of the alignment between Speaker’s and Listener’s attention weights as a proxy for the establishment of common understanding and show that the alignment correlates with task success.
Revised: We also investigate the potential of the alignment between Speaker’s and Listener’s attention weights as a proxy for the establishment of common understanding and show that the alignment correlates with task success.

Original:  E XPERIMENTAL F RAMEWORK 2. R EFERENTIAL G AME
Revised:  E XPERIMENTAL F RAMEWORK 2. R EFERENTIAL G AME

Original: We study emergent language in the referential game (Lewis, 1969; Lazaridou et al., 2017).
Revised: We study emergent language in the referential game (Lewis, 1969; Lazaridou et al., 2017).

Original: The game focuses on the most basic feature of language, referring to things.
Revised: The game focuses on the most basic feature of language, referring to things.

Original: The version of the referential game we adopt in this paper is structured as follows:
Revised: The version of the referential game we adopt in this paper is structured as follows:

Original: Speaker is presented with a target object o tgt ∈ O and generates a message m that consists of a sequence of discrete symbols.
Revised: Speaker is presented with a target object o tgt ∈ O and generates a message m that consists of a sequence of discrete symbols.

Original: Listener is presented with the message m and a candidate set C
Revised: Listener receives the message m and a candidate set C

Original: = { o 1 , o 2 , ..., o | C | } , which includes the target object o tgt and distractor objects sampled randomly without replacement from O . 3.
Revised: = { o 1 , o 2 , ..., o | C | } including the target object o tgt and distractor objects sampled randomly without replacement from O . 3.

Original: Listener chooses one object from the candidate set and if it is the target object, the game is considered successful. 
Revised: Listener chooses one object from the candidate set and if it is the target object, the game is considered successful. The objects can be represented as a set of attributes.

Revised: The focus of this game is whether agents can represent the objects in a compositional message that is supposedly based on the attributes

Original: 2. A GENT A RCHITECTURES
Revised: A GENT A RCHITECTURES

Original: Our goal in this paper is to test the effect of the attention mechanism on emergent language.
Revised: Our goal in this paper is to test the effect of the attention mechanism on emergent language.

Original: The attention mechanism in its general form takes a query vector Q and  key vectors K to compute attention weights over the keys.
Revised: The attention mechanism in its general form takes a query vector x and key-value vectors { y 1 , ..., y L } . The key-value vectors are optionally transformed into key vectors and value vectors or used as is.

Revised: Then, attention scores { s 1 , ..., s L } are calculated as the similarity between the query vector and the key vectors to the attention weights via the softmax function.

Original: Then the attention weights are used to produce a weighted sumvector of  value vectors V .
Revised: Finally, the attention weights are used to produce a weighted sum of the value vectors.

Original: A key feature of attention is that it allows the agents to selectively attend to a part of disentangled vector inputs.
Revised: A key feature of attention is that it allows the agents to selectively attend to a part of disentangled vector inputs.

Original: Our intuition is that modeling direct associations between the symbol representations as Q and disentangled input representations as K and V will bias agents toward packing each symbol with the information of a meaningful subpart of the inputs rather than with opaque and non-compositional information.
Revised: Our intuition is that modeling direct associations between the symbol representations as query and disentangled input representations as key-value will bias agents toward packing each symbol with the information of a meaningful subpart of the inputs rather than with opaque and non-compositional information.

Original: To test these hypotheses, we design non-attention and attention agents for both Speaker and Listener (Figure 1).
Revised: To test these hypotheses, we design non-attention and attention agents for both Speaker and Listener (Figure 1).

Original: 2.2. O BJECT E NCODER
Revised: 2.2. O BJECT E NCODER

Original: The objects are presented to the agents in the form of a set of real-valued vectors, e.g., attribute-wise one-hot vectors or patch-wise pretrained CNN feature vectors.
Revised: The objects are presented to the agents in the form of a set of real-valued vectors, e.g., attribute-wise one-hot vectors or patch-wise pretrained CNN feature vectors, as { o 1 , ..., o A } .

Original: All the Speaker and Listener agents have their individual object encoders.
Revised: All the Speaker and Listener agents have their individual object encoders.

Original: The input vectors are independently linear-transformed into the size of the agent’s hidden size and then successively go through the gelu activation (Hendrycks & Gimpel, 2016).
Revised: The input vectors are independently linear-transformed into the size of the agent’s hidden size and then successively go through the gelu activation (Hendrycks & Gimpel, 2016).

Original: The baseline non-attention agents average the transformed vectors into a single vector  for the subsequent computations, whereas the attention agents leave the transformed vectors intact and attend to the set of vectors.
Revised: The baseline non-attention agents average the transformed vectors into a single vector ˆ o for the subsequent computations, whereas the attention agents leave the transformed vectors intact and attend to the set of vectors { ˆ o 1 , ..., ˆ o A } .

Original: 2.2. S PEAKER A GENTS
Revised: 2.2. S PEAKER A GENTS

Original: Speaker has an auto-regressive message decoder that takes the transformed vectors of the target objecto tgt as input and generates a multi-symbol message m  .
Revised: Speaker has an auto-regressive message decoder that takes the encoded vector(s) of the target object as input and generates a multi-symbol message m = ( m 1 , ..., m T ) .

Original: There is a number of possible choices for the decoder architectureespecially with  attention (Bahdanau et al., 2015; Luong et al., 2015;
Revised: There is a number of possible choices for the decoder architecture with attention. To provide extensive empirical evidence on the effect of attention mechanism, we experiment with two common decoder architectures: the LSTM decoder from Luong et al.

Original:  Vaswani et al., 2017).
Revised: and the Transformer decoder from Vaswani et al.

Revised: At each time step t , the decoders embed a previously generated symbol into a vector m t − 1 and produce an output hidden vector through three steps: (1) recurrent computation; (2) attention; (3) post-processing.

Original: In this paper, we adopt the  Transformer decoder (Vaswani et al., 2017) because
Revised: As the decoders basically follow the original architecture, we only briefly describe each step in the LSTM and Transformer decoder with emphasis on how attention is incorporated. The more detailed descriptions can be found in Appendix C). The recurrent computation updates the input vector with the contextual information of previous inputs. The LSTM decoder uses a

Original:  Transformer naturally incorporates the attention mechanism in its basic architecture and is also a current de-facto standard and well-studied in a range of fields (Devlin et al., 2019; Schneider et al., 2019; Dosovitskiy et al., 2021).
Revised: LSTM cell (Hochreiter & Schmidhuber, 1997) and the Transformer decoder uses the self-attention mechanism (Vaswani et al., 2017). Then, with the contextualized input vector as the query x t and the object vectors as the key-value vectors { ˆ o 1 , ..., ˆ o A } , the decoders perform attention. The LSTM decoder uses the bilinear attention, where the attention score s i is computed as s it = x ⊤ t W b

Revised: ˆ

Original: Throughout this paper, the number of the  Transformersource-target attention heads is set to one for the sake of interpretability and ease of analysis.
Revised: o i , where W b is a learnable matrix. The attention vector is calculated as the weighted sum of the original key-value vectors. The Transformer attention fist linear-transforms the input vector as q t = W q x t , k i =

Revised: W k

Revised: ˆ o i , v i =

Revised: W v

Revised: ˆ o i , where

Revised: W q , W k , W v are learnable matrices.

Revised: Then the attention score is calculated using the scaled dot attention: s it =

Revised: ( q ⊤ t k i ) / √ d , where d is the dimension of the query and key vectors.

Revised: Finally, the attention vector is calculated as the weighted sum of the value vectors v i .

Revised: The original Transformer also has the multi-head attention mechanism, but in the main experiments, we set the number of the attention heads to one for interpretability and ease of analysis.

Revised: The effect of multi-head attention is investigated in Appendix E.

Revised: Finally, in the post-processing step, the original query vector x t and attended vector ˆ x t are integrated to produce the hidden vector to predict the next symbol.

Original: Non-attention (NoAT)
Revised: Non-attention (NoAT)

Original: Speaker is a baseline agent that encodes an object into a single vector and uses the vector as a source vector for the decoder.
Revised: Speaker is a baseline agent that encodes the target object into a single vector ˆ o tgt .

Original: The source-target attention in theTransformer decoder always attends to that single vector and does not change where to focus during message generation.
Revised: The source-target attention in the decoder always attends to that single vector and does not change where to focus during message generation.

Original: Attention (AT) Speaker , in contrast, encodes an object into a set of vectors  and the source-target attention dynamically changes its focus at each time step.
Revised: Attention (AT) Speaker , in contrast, encodes the target object into a set of vectors { ˆ o 1 tgt , ..., ˆ o Atgt } and the source-target attention dynamically changes its focus at each time step.

Original: Our agent design is motivated by a fair comparison of non-attention and attention agents.
Revised: Our agent design is motivated by a fair comparison of non-attention and attention agents.

Original: They have the same  number of parameters and only differ in whether they can dynamically change their focus when generating each symbol.
Revised: They have the same architecture and number of parameters and only differ in whether they can dynamically change their focus when generating each symbol.

Original: 2.2. L ISTNER A GENTS
Revised: 2.2. L ISTNER A GENTS

Original: Listener tries to predict the target object from a set of candidate objects C
Revised: Listener tries to predict the target object from a set of candidate objects C

Original: = { o 1 , o 2 , ..., o | C | } given the speaker message m by computing message-object matching scores  and choosing the object with the maximum score.
Revised: = { o 1 , o 2 , ..., o | C | } given the speaker message m by computing message-object matching scores { s 1 , ..., s | C | } and choosing the object with the maximum score.

Original: Non-attention (NoAT) Listener  encodes the objects  and  message into  a single vector respectively and computes the matching score by taking the dot product of the  object and message vectors.
Revised: Listener first encodes the objects using the object encoder and also encodes each symbol in the message into vectors { m 1 , ..., m T } using a message encoder, for which the LSTM-based agent uses the bidirectional LSTM and the Transformer-based agent uses the Transformer encoder. Non-attention (NoAT) Listener encodes each candidate object into a single vector ˆ o i .

Original: The message vector  is produced by feeding the message symbols to a Transformer encoder (Vaswani et al., 2017) and then averaging the outputs.
Revised: The agent also averages the encoded symbol vectors into a single vector m = 1 T (cid:80) Ti =1 m i . The messageobject matching score is computed by taking the dot product of the object and message vector s i = ˆ o ⊤

Original:  Attention (AT) Listener encodes the objects and message into a set of  vectors respectively and  the matching score is computed by averaging the symbol-object matching scores.
Revised: i m . In our experiments, the LSTM model uses the bidirectional LSTM encoder and the Transformer model uses the Transformer encoder. Attention (AT) Listener encodes each object into a set of attribute vectors { ˆ o 1 i , ..., ˆ o Ai } and use the encoded symbol vectors as it is.

Original: For each symbol, the model produces an attention vector  with thesymbol vector as a query and the object  vectors as keys and values.
Revised: With each encoded symbol vector m t as query, the model produces an attention vector ˆ m ti with the object attribute vectors as key-value using the dot-product attention.

Revised: Intuitively, the attention vector ˆ m ti is supposed to represent the attributes of the object o i relevant to the symbol m t .

Original: The symbol-object matching scores are then calculated as the dot product of the symbol vector and the attention vector.
Revised: Then, the symbol-object matching score is computed by taking the dot product between the attention vector and the message vector: s ti = ˆ m t ⊤ i m t .

Revised: Finally, the symbol-object matching scores are averaged to produce the message-object matching score: s i = 1 T (cid:80) t s ti .

Original: 2. O PTIMIZATION
Revised: 2. O PTIMIZATION

Original: The parameters of Speaker θ S and Listener θ L are both optimized toward the task success.
Revised: The parameters of Speaker θ S and Listener θ L are both optimized toward the task success.

Original: Speaker is trained with the REINFORCE algorithm (Williams, 1992).
Revised: Speaker is trained with the REINFORCE algorithm (Williams, 1992).

Original: The message decoder produces the probability distribution of which symbol to generate π θ S ( ·| t ) at each time step t .
Revised: The message decoder produces the probability distribution of which symbol to generate π θ S ( ·| t ) at each time step t .

Original: At training time, message symbols are randomly sampled according to the predicted probabilities and the loss function for the Speaker message policy is L π ( θ S )
Revised: At training time, message symbols are randomly sampled according to the predicted probabilities and the loss function for the Speaker message policy is L π ( θ S )

Original: = (cid:80) t r log( π θ S ( m t | t )) where m t denotes the t -th symbol in the message.
Revised: = (cid:80) t r log( π θ S ( m t | t )) where m t denotes the t -th symbol in the message.

Original: The reward r is set to 1 for the task success and 0 otherwise.
Revised: The reward r is set to 1 for the task success and 0 otherwise.

Original: As an auxiliary loss function, we employ an entropy regularization loss L H ( θ S )
Revised: As an auxiliary loss function, we employ an entropy regularization loss L H ( θ S )

Original: = − (cid:80) t H ( π θ S ( ·| t )) , where H is the entropy of a probability distribution, to encourage exploration.
Revised: = − (cid:80) t H ( π θ S ( ·| t )) , where H is the entropy of a probability distribution, to encourage exploration.

Original: We also add a KL loss L KL ( θ S )
Revised: We also add a KL loss L KL ( θ S )

Original: = (cid:80) t D KL ( π θ S ( ·| t )
Revised: = (cid:80) t D KL ( π θ S ( ·| t )

Original: ∥
Revised: ∥

Original: π ¯ θ S ( ·| t )) , where the policy π ¯ θ S is obtained by taking an exponential moving average of the weights of θ S over training, to stabilize the training (Chaabouni et al., 2022).
Revised: π ¯ θ S ( ·| t )) , where the policy π ¯ θ S is obtained by taking an exponential moving average of the weights of θ S over training, to stabilize the training (Chaabouni et al., 2022).

Original: In summary, the final speaker loss is L ( θ S ) =
Revised: In summary, the final speaker loss is L ( θ S ) =

Original: L π ( θ S ) + α L H ( θ S ) + β L KL ( θ S ) , where α and β are hyperparameters.
Revised: L π ( θ S ) + α L H ( θ S ) + β L KL ( θ S ) , where α and β are hyperparameters.

Original: Listener is trained with a multi-class classification loss.
Revised: Listener is trained with a multi-class classification loss.

Original: The message-object matching scores are converted through the softmax operation to p θ
Revised: The message-object matching scores are converted through the softmax operation to p θ

Original: L
Revised: L

Original: ( o i | C ) , the probability of choosing the object o i as the target from the candidate set C .
Revised: ( o i | C ) , the probability of choosing the object o i as the target from the candidate set C .

Original: Then Listener is trained to maximize the probability of predicting the target object by minimizing the loss function L ( θ L ) =
Revised: Then Listener is trained to maximize the probability of predicting the target object by minimizing the loss function L ( θ L ) =

Original: − log p θ L ( o tgt | C ) .
Revised: − log p θ L ( o tgt | C ) .

Original: The details of hyperparameter settings and training procedures can be found in Appendix A.3.
Revised: The details of hyperparameter settings and training procedures can be found in Appendix A.3.

Original: 2. E VALUATION M ETRICS
Revised: 2. E VALUATION M ETRICS

Original: We quantitatively evaluate emergent languages fromtwo perspectives: (1) how well the language can be used to solve the task and(2) how well the language exhibits compositionality. 
Revised: We quantitatively evaluate emergent languages from how well the language can be used to solve the task and how well the language exhibits compositionality. Training accuracy (TrainAcc) measures the task performance with objects seen during training. This indicates how the agent architectures are simply effective to solve the referential game.

Original: Generalization accuracy (Acc) measures the task performance with objects unseen during training.
Revised: Generalization accuracy (GenAcc) measures the task performance with objects unseen during training.

Original: We split the distinct object types in the game into train and evaluation sets and the generalization accuracy is computed with the evaluation set.
Revised: We split the distinct object types in the game into train and evaluation sets and the generalization accuracy is computed with the evaluation set.

Original: As each object can be represented as a combination of attribute values, what we expect for the agents is to learn to combine symbols denoting each attribute value in a systematic way so that the language can express unseen combinations of known attribute values.
Revised: As each object can be represented as a combination of attribute values, what we expect for the agents is to learn to combine symbols denoting each attribute value in a systematic way so that the language can express unseen combinations of known attribute values.

Original: Topographic similarity (TopSim) , also known as Representational Similarity Analysis (Kriegeskorte et al., 2008), is one of the most commonly used metrics to assess the compositionality of emergent language (Brighton & Kirby, 2006;
Revised: Topographic similarity (TopSim) , also known as Representational Similarity Analysis (Kriegeskorte et al., 2008), is one of the most commonly used metrics to assess the compositionality of emergent language (Brighton & Kirby, 2006;

Original: Lazaridou et al., 2018;
Revised: Lazaridou et al., 2018;

Original: Ren et al., 2020; Chaabouni et al., 2020).
Revised: Ren et al., 2020; Chaabouni et al., 2020).

Original: Intuitively, TopSim checks if similar objects have similar messages assigned.
Revised: Intuitively, TopSim checks if similar objects have similar messages assigned.

Original: To compute TopSim, we enumerate all the object-message pairs ( o 1 , m 1 ) , ...., ( o |O| , m |O| ) with a trained Speaker and define a distance function for objects d
Revised: To compute TopSim, we enumerate all the object-message pairs ( o 1 , m 1 ) , ...., ( o |O| , m |O| ) with a trained Speaker and define a distance function for objects d

Original: O
Revised: O

Original: ( o i , o j ) and messages d M ( m i , m j ) .
Revised: ( o i , o j ) and messages d M ( m i , m j ) .

Original: Then we compute
Revised: Then we compute

Original: Spearman’s correlation between pairwise distances in the object and message space.
Revised: Spearman’s correlation between pairwise distances in the object and message space.

Original: For the distance function for objects d O ( o i , o j ) , we use the cosine distance of the binary attribute value vectors and for the distance function of messages d M ( m i , m j ) the edit distance of message symbols.
Revised: For the distance function for objects d O ( o i , o j ) , we use the cosine distance of the binary attribute value vectors and for the distance function of messages d M ( m i , m j ) the edit distance of message symbols.

Original: Positioanl disentanglement (PosDis) measures if each position in the message is associated with a particular attribute of the object (Chaabouni et al., 2020).

Original: For example, when an English speaker describes objects with color and shape attributes, they would say “red circle” and “blue triangle” with consistent word order, not “red circle” and “triangle blue”.

Original: PosDis assigns high scores for such order-dependent languages.

Original: Suppose each object o has n attributes { a (1 , o ) , ..., a ( n, o ) } .

Original: Given the object-message pairs, we compute the mutual information between the i -th attributes of the objects a ( i ; o ) and symbols at the j -th position s ( j ; m ) in the messages: I ( a ( i ; o ) , s ( j ; m )) .

Original: PosDis of the position j is computed by finding the attributes with the highest mutual information I j ( n ) = max i

Original: I ( a ( i ; o ) , s ( j ; m )) and the second highest I j ( n − 1) , taking the difference between them, and then normalizing the difference by the entropy of j -th position: I j ( n ) −I j ( n − 1) H ( s ( j ; m )) .

Original: The final PosDis score is the average of the position-wise values over the positions with the values with zero entropy ignored.

Original: Bag-of-symbols disentanglement (BosDis) captures position-agnostic correspondence between message symbols and object attributes (Chaabouni et al., 2020).

Original: For each message symbol s k in the vocabulary, we count its occurrence in each message m : c ( s k ; m ) .

Original: BosDis of the symbol s k is computed by finding the attributes with the highest mutual information

Original: I k ( n ) = max i

Original: I ( a ( i ; o ) , c ( s k ; m )) and second highest

Original: I k ( n − 1) , taking the difference between their mutual information, and then normalizing the difference by the entropy of the count: I k ( n ) −I k ( n − 1) H ( c ( s k ; m )) .

Original: The final BosDis score is the average of the symbol-wise values over vocabulary with symbols with the values with zero entropy ignored.

Original:  E XPERIMENTAL S ETUP 3. O NE - HOT G AME
Revised:  E XPERIMENTAL S ETUP 3. O NE - HOT G AME

Original: Our first experimental setting is the referential game with objects consisting of one-hot vectors (Lazaridou et al., 2017; Kottur et al., 2017; Chaabouni et al., 2020;
Revised: Our first experimental setting is the referential game with objects consisting of one-hot vectors (Lazaridou et al., 2017; Kottur et al., 2017; Chaabouni et al., 2020;

Original: Guo et al., 2022).
Revised: Guo et al., 2022).

Original: The objects are represented as a combination of two attributes (e.g., shape and color), which is a popular setting in the literature (Li & Bowling, 2019; Ren et al., 2020).
Revised: The objects are represented as a combination of two attributes (e.g., shape and color), which is a popular setting in the literature (Li & Bowling, 2019; Ren et al., 2020).

Original: Each attribute has 8 possible values, which results in 64 distinct objects.
Revised: Each attribute has 8 possible values, which results in 64 distinct objects.

Original: To evaluate generalization to unseen objects, we randomly split the 64 objects into training and evaluation sets at a ratio of 48/16.
Revised: To evaluate generalization to unseen objects, we randomly split the 64 objects into training and evaluation sets at a ratio of 48/16.

Original: The number of candidates is set to 16, which is the maximum number of objects available in the evaluation set.
Revised: The number of candidates is set to 16, which is the maximum number of objects available in the evaluation set.

Original: Input Representation.
Revised: Input Representation.

Original: The objects are disentangled in terms of attributes and represented as a set of one-hot vectors where each dimension indicates a different value of a different attribute (i.e., two 16-dim one-hot vectors).
Revised: The objects are disentangled in terms of attributes and represented as a set of one-hot vectors where each dimension indicates a different value of a different attribute (i.e., two 16-dim one-hot vectors).

Original: Agent Configurations.
Revised: Agent Configurations.

Original: The vocabulary size of the agents is set to 16 and the message length of
Revised: The vocabulary size of the agents is set to 16 and the message length of

Original: Speaker is 2.
Revised: Speaker is 2.

Original: In this setting, a perfectly compositional language that scores the maximum score for all the compositionality metrics would assign different symbols to each attribute value, and symbols at each position consistently refer to a single attribute.
Revised: In this setting, a perfectly compositional language that scores the maximum score for all the compositionality metrics would assign different symbols to each attribute value, and symbols at each position consistently refer to a single attribute.

Original: 3. F ASHION -MNIST G AME
Revised: 3. F ASHION -MNIST G AME

Original: Attention has been shown to be able to associate a symbol and a relevant region of an image to solve the task (Xu et al., 2015; Yang et al., 2016).
Revised: Attention has been shown to be able to associate a symbol and a relevant region of an image to solve the task (Xu et al., 2015; Yang et al., 2016).

Original: To develop human-like emergent languages, one important question is whether the attention agents are able to develop a language such that we can understand the meaning of each symbol by inspecting the attended region.
Revised: To develop human-like emergent languages, one important question is whether the attention agents are able to develop a language such that we can understand the meaning of each symbol by inspecting the attended region.

Original: For this purpose, we design a multi-item image referential game to test if the agents develop attention patterns for each symbol that focus on a single item in a given image.
Revised: For this purpose, we design a multi-item image referential game using the Fashion-MNIST dataset 1 (Xiao et al., 2017). In this game, each object is defined as a combination of two classes from the Fashion-MNIST dataset (e.g., T-shirt and Sneaker ).

Original: The items in each image are taken from the 
Revised: The dataset contains 10 classes and thus the game has 10 C 2 = 45 different types of objects. The 45 types are randomly divided into training and evaluation sets at a ratio of 30/15, and the number of candidates is set to 15.

Original: Fashion-MNIST dataset 1 (Xiao et al., 2017).
Revised: Input Representation.

Original: The images for the game are created by placing two item images, each of which is rescaled to the size of 48 × 48 , on a 224 × 224 black canvas (Figure 3).
Revised: Each object is presented to the agents as feature vectors extracted from a pixel image. The image is created by placing two item images, each of which is rescaled to the size of 48 × 48 , on a 224 × 224 black canvas (Figure 4).

Original: The places of the items are randomly sampled so that the items never overlap.
Revised: The places of the items are randomly sampled so that the items never overlap.

Original: As we would like to let the agents capture concepts that are understandable by humans, we design the game so that the agents have to communicate the classes of the items in each image rather than distinguish among specific instances of images to avoid degenerated solutions  (Lazaridou et al., 2018; Bouchacourt & Baroni, 2018).The objects in the game are distinguished solely by the classes of items e.g., two images with different pairs of a T-shirt and sneaker in different positions are considered to be the same object. The Fashion-MNIST dataset has 10 item classes and thus the game has 10 C 2 = 45 different types of objects.
Revised: The specific item images and their positions are randomly sampled every time the agents process the objects both during training and evaluation time to avoid degenerated solutions that exploit spurious features of an image (Lazaridou et al., 2018; Bouchacourt & Baroni, 2018).

Original: Also, the Speaker and Listener are presented with different imageswithin the same type as the target  to facilitate learning a robust communication protocol (Rodr´ıguez Luna et al., 2020).
Revised: Also, the Speaker and Listener are presented with different images as the target object to facilitate learning a robust communication protocol (Rodr ´ ıguez Luna et al., 2020).

Original: The 45 types are randomly divided into training and evaluation sets at a ratio of 30/15, and the number of candidates is set to 15.

Original: Input representation.

Original: Each image is encoded into 7 × 7 × 768 -dim feature vectors with a pretrained ConvNet 2 (Liu et al., 2022).
Revised: Each image is encoded into 7 × 7 × 768 -dim feature vectors with a pretrained ConvNet 2 (Liu et al., 2022).

Original: For non-attention models, the feature vectors are averaged across spatial axes into a single 768-dim feature vector.
Revised: For non-attention models, the feature vectors are averaged across spatial axes into a single 768-dim feature vector.

Original: Agent Configurations.
Revised: Agent Configurations.

Original: The vocabulary size of the agents is set to 20 and the message length is 2.
Revised: The vocabulary size of the agents is set to 20 and the message length is 2.

Original: A perfectly compositional language would refer to each item in the image with different symbols with a consistent one-to-one mapping.  
Revised: A perfectly compositional language would refer to each item in the image with different symbols with a consistent one-to-one mapping.  R ESULTS 4. A TTENTION AGENTS FIND MORE COMPOSITIONAL SOLUTIONS

Revised: We evaluate non-attention agents and attention agents where either/both Speaker and Listener have dynamic attention.

Original: More details of the experimental setup are found in Appendix A.
Revised: We perform hyperparameter tuning as described in Appendix A and plot the

Original: The pretrained model is registered as convnext tiny in the torchvision library
Revised: The pretrained model is registered as convnext tiny in the torchvision library

Original: [Table]
Revised: [Figure]

Original: We evaluate non-attention agents and attention agentswhere either/both Speaker and Listener have dynamic attention. The generalization accuracy and compositionality metrics in the one-hot and Fashion-MNIST games are presented in Table 1.
Revised: results of top-10 agents in terms of GenAcc for each setting on Figure 2.

Original: The PosDis metric cannot be computed for the Fashion-MNIST game as the game defines only a single attribute for the objects.
Revised: We do not discuss the difference between the LSTM and Transformer agents as they differ in multiple dimension in their architectures.

Original:  We observe a general trend that the attention agents perform better than the non-attention baseline (NoAT-NoAT), which is indicated by the better average scores in task generalization (Acc) and compositionality metrics (TopSim, PosDis, and BosDis) with different degrees of significance.
Revised: Here, we focus on the difference between the non-attention and attention agents within each architecture. We observe a general trend that the attention agents perform better than the non-attention baseline (NoAT-NoAT), which is indicated by the better average scores in task generalization (GenAcc) and compositionality metrics (TopSim) with different degrees of significance.

Original: This observation provides evidence in support of the hypothesis that  attention  creates pressure for learning more compositional emergent languages.
Revised: This observation provides evidence in support of the hypothesis that the attention mechanism creates pressure for learning more compositional emergent languages.

Original: When looking at Acc and TopSim, AT-NoAT performs better than NoAT-AT, suggesting the effect  of the  attention mechanisms implemented in this study is stronger at the Speaker side.
Revised: One possible interpretation is that the attention mechanism adds flexibility to the model and it simply leads to better learning of the task. We observe the effect in the TrainAcc of the Fashion-MNIST game, where the attention models consistently outperform their non-attention baselines. However, we can still see the contribution of the attention mechanism besides the flexibility.

Original: When looking at more fine-grained metrics in the one-hot game, we see that AT-NoAT provides a  significantly  better PosDis score than that of NoAT-AT (39.3 ± 19.5 vs. 21.4 ± 12.0, p < 0 .
Revised: We can see some NoAT-NoAT agents and AT-AT agents exhibit comparable TrainAcc around 75% in the FashionMNIST game, which means they are successful at optimization to a similar degree. However, we observe all the AT-AT agents significantly outperform any of the NoAT-NoAT agents, which indicates the degree of optimization alone cannot explain the better GenAcc and TopSim scores of the attention model.

Original: in Welch’s t-test) but not for BosDis (54.7 ± 6.8 vs. 67.5 ± 11.5, p ≥ 0 . 05 ), suggesting that theSpeaker attention helps developing a language with consistent word order (e.g., the first symbols usually refer to the shape attribute) more than the Listener attention.
Revised: Therefore, the results supports our initial hypothesis that the attention mechanism facilitates developing compositional languages.

Original: AT-AT provides a performance mostly comparable toAT-NoAT as a statistically significant difference between them is only observed in BosDis (62.6 ± 12.2 vs. 54.7 ± 6.8, p < 0 . 05 ) in the one-hot  game.
Revised: In some settings, we observe that adding the attention mechanism to only one of Speaker and Listener does not lead to better TopSim scores compared the NoAT-NoAT agents to as in the AT-NoAT LSTM agents in the one-hot game, and the AT-NoAT and NoAT-AT LSTM agents in the FashionMNIST game.

Original: Although having attention at both Speaker and Listenerdoes not provide significant improvements in this setting, we will show in §4.3 that the double-attention agents enable us to inspect thealignment of Speaker’s and Listener’s attention weights, which  is an informative indicator for communication success.
Revised: However, when both Speaker and Listener agents have the attention mechanism, they all exhibit more generalizable and compositional languages, which indicates the effect of attention in Speaker and Listener is multiplicative.

Original: 4. A TTENTION AGENTS LEARN TO ASSOCIATE INPUT ATTRIBUTES AND SYMBOLS
Revised: 4. A TTENTION AGENTS LEARN TO ASSOCIATE INPUT ATTRIBUTES AND SYMBOLS

Original: Having confirmed that the attention agents give rise to more compositional languages, we proceed to examine if they use attention in an expected way, i.e., producing/understanding each symbol by associating them with a single input concept. 
Revised: Having confirmed that the attention agents give rise to more compositional languages, we proceed to examine if they use attention in an expected way, i.e., producing/understanding each symbol by associating them with a single input concept. We focus on analyzing the Transformer agents below.

Original: Figure 2 shows the distributions of the attention weights assigned to each input attribute vector in the one-hot game.
Revised: [Figure] [Figure]

Original: We observe that most attention weights are around either 0 or 1, indicating that the attention agents generally learn to focus attention on a single value, which may have contributed to more compositional languages.
Revised: Inspecting the distributions of the attention weights assigned to each input attribute vector in the one-hot game, we observed that most attention weights are around either 0 or 1, indicating that the attention agents generally learn to focus attention on a single value (Figure 3).

Original: We also inspect the attention weights in the Fashion-MNIST game and confirm that attention agents generally learn to focus on a single object when generating a symbol as in Figure 3(a)-(d), although there are some failure cases as shown in Figure 3(e)-(f).
Revised: We also inspect the attention weights in the Fashion-MNIST game and confirm that attention agents generally learn to focus on a single object when generating a symbol as in Figure 4(a)-(d), although there are some failure cases as shown in Figure 4(e)-(f).

Original: Given the observations above, we can associate each symbol in each message with the concepts defined in the game via attention weights.
Revised: Given the observations above, we can associate each symbol in each message with the concepts defined in the game via attention weights.

Original: We visualize the association between each symbol in the vocabulary and each concept from a pair of AT-AT agents in Figure 4 to inspect the mapping[Figure] [Figure] patterns developed by the agents.
Revised: We visualize the association between each symbol in the vocabulary and each concept from a pair of AT-AT agents in Figure 5 to inspect the mapping patterns developed by the agents.

Original: A symbol is considered to be associated with a concept when the attribute value has the largest attention weight in the one-hot game or the center of gravity of the attention weights is within the bounding box of the item in the Fashion-MNIST game.
Revised: A symbol is considered to be associated with a concept when the attribute value has the largest attention weight in the one-hot game or the center of gravity of the attention weights is within the bounding box of the item in the Fashion-MNIST game.

Original: Overall, we observe that the mappings learned by Speaker and Listener are mostly aligned except for the symbol c in the one-hot game and the symbol i in the Fashion-MNIST game.
Revised: Overall, we observe that the mappings learned by Speaker and Listener are mostly aligned except for the symbol c in the one-hot game and the symbol i in the Fashion-MNIST game.

Original: We identify three types of symbol-to-concept mapping patterns.
Revised: We identify three types of symbol-to-concept mapping patterns.

Original: Monosemy.
Revised: Monosemy.

Original: A single symbol always refers to a single concept, e.g., a , b , and d in the one-hot game; a , e , and g in the Fashion-MNIST game.
Revised: A single symbol always refers to a single concept, e.g., a , b , and d in the one-hot game; a , e , and g in the Fashion-MNIST game.

Original: This is a desired mapping pattern that allows an unambiguous interpretation of symbols.
Revised: This is a desired mapping pattern that allows an unambiguous interpretation of symbols.

Original: However, we also observe “synonyms” where a single concept is referred to by multiple symbols, e.g., 1-3 by d and e in the one-hot game.
Revised: However, we also observe “synonyms” where a single concept is referred to by multiple symbols, e.g., 1-3 by d and e in the one-hot game.

Original: Polysemy.
Revised: Polysemy.

Original: A single symbol refers to multiple concepts, e.g., j - n in the one-hot game; b , c , and d in the Fashion-MNIST game.
Revised: A single symbol refers to multiple concepts, e.g., j - n in the one-hot game; b , c , and d in the Fashion-MNIST game.

Original: These symbols are somewhat ambiguous, but it is likely that the agents develop a way to resolve the ambiguity, especially in the one-hot game. In the one-hot game, agents achieve more than 90% average accuracy scores with unseen objects and relatively high PosDis scores (Table 1).
Revised: These symbols are somewhat ambiguous, but it is likely that the agents develop a way to resolve the ambiguity, especially in the one-hot game where agents achieve more than 90% average accuracy scores with unseen objects.

Original: Moreover, these polysemous symbols always refer to two values of the different attributes.
Revised: Moreover, these polysemous symbols always refer to two values of the different attributes.

Original: Given these observations, the agents are likely to have learned a consistent word order in terms of the object attributes and disambiguated the polysemous symbols by their position.
Revised: Given these observations, the agents are likely to have learned a consistent word order in terms of the object attributes and disambiguated the polysemous symbols by their position.

Original: The polysemous symbols in the Fashion-MNIST game seem to be affected by the visual similarity of the fashion items, e.g., b refers to tops (Pullover, Coat, and Shirt) and f refers to shoes (Sandal,
Revised: The polysemous symbols in the Fashion-MNIST game seem to be affected by the visual similarity of the fashion items, e.g., b refers to tops (Pullover, Coat, and Shirt) and f refers to shoes (Sandal,

Original: Sneaker, and Boot).
Revised: Sneaker, and Boot).

Original: This is in contrast to the one-hot game, where the object attribute representations are initialized randomly, which probably led to an arbitrary assignment of polysemy.
Revised: This is in contrast to the one-hot game, where the object attribute representations are initialized randomly, which probably led to an arbitrary assignment of polysemy.

Original: The polysemous patterns in the Fashion-MNIST game demonstrate that the semantics of emergent language can be heavily influenced by the property of the input objects.
Revised: The polysemous patterns in the Fashion-MNIST game demonstrate that the semantics of emergent language can be heavily influenced by the property of the input objects.

Original: Gibberish.
Revised: Gibberish.

Original: We observe a few cases where the attention weights do not consistently focus on any particular regions in the Fashion-MNIST game, e.g., the symbol i .
Revised: We observe a few cases where the attention weights do not consistently focus on any particular regions in the Fashion-MNIST game, e.g., the symbol i .

Original: These gibberish symbols could have conveyed something informative but uninterpretable to humans, but we confirmed that the  communication success rate with the gibberish symbols is much lower (19.4%) than the overall success rate (45.3%), indicating that the gibberish symbols are the results of optimization failure.
Revised: These gibberish symbols could have conveyed something informative but uninterpretable to humans, but we confirmed that the [Figure] [Figure] communication success rate with the gibberish symbols is much lower (19.4%) than the overall success rate (45.3%), indicating that the gibberish symbols are the results of optimization failure.

Original: 4. T HE COORDINATION OF S PEAKER AND L ISTENER ATTENTIONS PREDICTS THE TASK PERFORMANCE
Revised: 4. T HE COORDINATION OF S PEAKER AND L ISTENER ATTENTIONS PREDICTS THE TASK PERFORMANCE

Original: An important prerequisite of successful communication is the participants engaging in joint attention and establishing a shared understanding of each word (Garrod & Pickering, 2004).
Revised: An important prerequisite of successful communication is the participants engaging in joint attention and establishing a shared understanding of each word (Garrod & Pickering, 2004).

Original: Here we show[Figure] [Figure] that the degree of the alignment between Speaker’s and Listener’s attention weights can be regarded as a proxy of their mutual understanding and predictive of communication success.
Revised: Here we show that the degree of the alignment between Speaker’s and Listener’s attention weights can be regarded as a proxy of their mutual understanding and predictive of communication success.

Original: We define a metric called attention discrepancy , which measures the difference between the attention weights of Speaker and Listener given the same inputs.
Revised: We define a metric called attention discrepancy , which measures the difference between the attention weights of Speaker and Listener given the same inputs.

Original: The metric is calculated by computing the
Revised: The metric is calculated by computing the

Original: Jensen–Shannon Divergence (Lin, 1991) between the Speaker’s and Listener’s attention maps.
Revised: Jensen–Shannon Divergence (Lin, 1991) between the Speaker’s and Listener’s attention maps.

Original: Figure 5 shows the frequency of attention discrepancy scores within successful and failed communications.
Revised: Figure 6 shows the frequency of attention discrepancy scores within successful and failed communications.

Original: 3 We can see that successful communications can be characterized by lower attention discrepancy compared to failed communications, indicating that the alignment of the attention weights does correlate with communication success.
Revised: 3 We can see that successful communications can be characterized by lower attention discrepancy compared to failed communications, indicating that the alignment of the attention weights does correlate with communication success.

Original: This suggests that the attention agents largely develop intuitive communication protocols that require a shared understanding of symbols.
Revised: This suggests that the attention agents largely develop intuitive communication protocols that require a shared understanding of symbols.

Original:  R ELATED W ORK 5. E MERGENT L ANGUAGE
Revised:  R ELATED W ORK 5. E MERGENT L ANGUAGE

Original: One of the desired properties of emergent language is compositionality because more compositional languages are supposed to be intuitive, interpretable, generalizable, and easier to learn (Li & Bowling, 2019;
Revised: One of the desired properties of emergent language is compositionality because more compositional languages are supposed to be intuitive, interpretable, generalizable, and easier to learn (Li & Bowl- ing, 2019;

Original: Ren et al., 2020).
Revised: Ren et al., 2020).

Original: Compositional languages in this context usually have symbols each of which corresponds to one of the primitive concepts in the environment and combine them in a straightforward manner to form a message.
Revised: Compositional languages in this context usually have symbols each of which corresponds to one of the primitive concepts in the environment and combine them in a straightforward manner to form a message.

Original: Existing studies have investigated various environmental pressures to improve the compositionality of emergent language: learning across generations (Li &
Revised: Existing studies have investigated various environmental pressures to improve the compositionality of emergent language: learning across generations (Li &

Original: Bowling, 2019; Ren et al., 2020), learning with a population (Rita et al., 2022), applying noise to communication channel (Kuci´nski 
Revised: Bowling, 2019; Ren et al., 2020), learning with a population (Rita et al., 2022), applying noise to communication channel (Kuci´nski et al., 2021).

Original: [Table] These recent studies have been mainly conducted with simple RNN-based Speaker and Listener agents, where the inputs (e.g., attribute values or raw images) are encoded into a single input vector for subsequence computations.
Revised: These recent studies have been mainly conducted with simple RNN-based Speaker and Listener agents, where the inputs (e.g., attribute values or raw images) are encoded into a single input vector for subsequence computations.

Original: Other agent architectures have been employed for other specific motivations.
Revised: Other agent architectures have been employed for other specific motivations.

Original: Chaabouni et al.
Revised: Chaabouni et al.

Original: and Ryo et al.
Revised: and Ryo et al.

Original: (2022) used the LSTM sequence-to-sequence (with attention) architecture to study how agents transduce a sequential input generated from a certain grammar to their own emergent language.
Revised: (2022) used the LSTM sequence-to-sequence (with attention) architecture to study how agents transduce a sequential input generated from a certain grammar to their own emergent language.

Original: Gupta et al.
Revised: Gupta et al.

Original: (2021) developed a patch-based Speaker architecture that produces messages by focusing important image patches.
Revised: (2021) developed a patch-based Speaker architecture that produces messages by focusing important image patches.

Original: One of our goals in this study is to investigate how the inductive biases of the Speaker and Listener architectures affect the compositionality of the emergent language.
Revised: One of our goals in this study is to investigate how the inductive biases of the Speaker and Listener architectures affect the compositionality of the emergent language.

Original: In a similar spirit, Słowik et al.
Revised: In a similar spirit, Słowik et al.

Original: compared Speaker agents which process inputs in the form of a graph, sequence, and bag-ofwords and show that the graph architecture exhibits more compositional emergent languages.
Revised: compared Speaker agents which process inputs in the form of a graph, sequence, and bag-ofwords and show that the graph architecture exhibits more compositional emergent languages.

Original: Our study offers additional empirical evidence in this direction with the attention mechanism.
Revised: Our study offers additional empirical evidence in this direction with the attention mechanism.

Original: 5. A TTENTION M ECHANISM
Revised: 5. A TTENTION M ECHANISM

Original: The attention mechanism has been shown very effective in supervised learning (Xu et al., 2015;
Revised: The attention mechanism has been shown very effective in supervised learning (Xu et al., 2015;

Original: Vaswani et al., 2017)
Revised: Vaswani et al., 2017)

Original: and has become an indispensable modeling piece in modern neural networks.
Revised: and has become an indispensable modeling piece in modern neural networks.

Original: Conceptually,  attention  models pairwise associations between a query vector and  key-value vectors.
Revised: Conceptually, the attention mechanism models pairwise associations between a query vector and a subset of key-value vectors.

Original: We hypothesize that this can provide an inductive bias for the agents in the referential game to learn a one-to-one mapping between symbols and concepts. Some studies have shown that attention can help the model reach compositional solutions. Hupkes et al.and
Revised: This enables the model to focus on a subpart of compositional representation and has been shown to enforce composition solutions in various settings such as visual reasoning (Hudson & Manning, 2018), symbolic reasoning Korrel et al.

Original: Baan et al. (2019) investigated a technique called attentive guidance , which leads the model to converge to compositional solutions by adding supervision for the attention weights. Korrel et al. (2019) also showed that a model with attention converges to more compositional solutions compared to its non-attention counterpart in a lookup table task.
Revised: (2019), image generation (Hudson & Zitnick, 2021).

Original: Our study demonstrates that the agents with  the attention mechanism can find more compositional languages in the referential game without any additional supervision.
Revised: Our study demonstrates that by modeling association between a symbol and an object attribute with attention, the agents can find more compositional languages in the referential game without any additional supervision.

Original: Another potential benefit of attention is interpretability.
Revised: Another potential benefit of attention is interpretability.

Original: Attention has been shown to provide plausible alignment patterns between inputs and outputs, for example, source and target words in machine translation (Bahdanau et al., 2015) and image regions and words in image captioning
Revised: Attention has been shown to provide plausible alignment patterns between inputs and outputs, for example, source and target words in machine translation (Bahdanau et al., 2015) and image regions and words in image captioning

Original: (Xu et al., 2015; Yang et al., 2016).
Revised: (Xu et al., 2015; Yang et al., 2016).

Original: On the other hand, the alignment patterns may need careful interpretation.
Revised: On the other hand, the alignment patterns may need careful interpretation.

Original: The patterns are not always consistent with human intuitions (Alkhouli et al., 2018; Liu et al., 2020) and there is an ongoing debate about to what extent the attention weights can be used as explanations for model prediction (Jain & Wallace, 2019; Wiegreffe & Pinter, 2019; Bibal et al., 2022).
Revised: The patterns are not always consistent with human intuitions (Alkhouli et al., 2018; Liu et al., 2020) and there is an ongoing debate about to what extent the attention weights can be used as explanations for model prediction (Jain & Wallace, 2019; Wiegreffe & Pinter, 2019; Bibal et al., 2022).

Original: In this paper, our agents show relatively straightforward attention patterns that allow unambiguous interpretations but the interpretability of attention weights with more complex models and environments needs further investigation in the future.
Revised: In this paper, our agents show relatively straightforward attention patterns that allow unambiguous interpretations but the interpretability of attention weights with more complex models and environments needs further investigation in the future.

Original:  D ISCUSSION AND C ONCLUSION
Revised:  D ISCUSSION AND C ONCLUSION

Original: When we face a complex object, we are likely to dynamically change our focus on its subpart to describe the whole (Rensink, 2000).
Revised: When we face a complex object, we are likely to dynamically change our focus on its subpart to describe the whole (Rensink, 2000).

Original: Hearing a word helps us quickly recognize its referent (Boutonnet & Lupyan, 2015) and affects where to focus in an image (Estes et al., 2008).
Revised: Hearing a word helps us quickly recognize its referent (Boutonnet & Lupyan, 2015) and affects where to focus in an image (Estes et al., 2008).

Original: Motivated by these psychological observations, we implemented agents with the dynamic interaction between symbols and input representations in the form of the attention mechanism.
Revised: Motivated by these psychological observations, we implemented agents with the dynamic interaction between symbols and input representations in the form of the attention mechanism.

Original: We showed that the attention agents develop more compositional languages than the non-attention agents.
Revised: We showed that the attention agents develop more compositional languages than their non-attention counterparts.

Original: This implies that the human ability to focus might have contributed to developing compositional language.
Revised: This implies that the human ability to focus might have contributed to developing compositional language.

Original: Overall, our results suggest that future work should explore more architectural variations that originate from human cognitive processing to gain insights into the effect of the cognitive property on shaping a language.
Revised: Overall, our results suggest that future work should explore more architectural variations that originate from human cognitive processing to gain insights into the effect of the cognitive property on shaping a language.

Original: Given the observation that the alignment of Speaker’s and Listener’s attention is somewhat indicative of successful communication in §4.3, for example, future work can explore how incorporating joint attention (Kwisthout et al., 2008) into training helps to learn a language.
Revised: Given the observation that the alignment of Speaker’s and Listener’s attention is somewhat indicative of successful communication in §4.3, for example, future work can explore how incorporating joint attention (Kwisthout et al., 2008) into training helps to learn a language.

Original: R EPRODUCIBILITY S TATEMENT
Revised: R EPRODUCIBILITY S TATEMENT

Original: The experiments described in this paper are ensured to be reproducible in the following ways:
Revised: The experiments described in this paper are ensured to be reproducible in the following ways:

Original: • We describe the task setup and models in §2 together with more specific descriptions of each task in §3.
Revised: • We describe the task setup and models in §2 together with more specific descriptions of each task in §3.

Original: The additional details and hyperparameters to reproduce the results are given in appendix A. • The artifacts used in the experiments (the Fashion-MNIST dataset and pretrained ConvNet encoder in §3.2) are all publicly available.
Revised: The additional details and hyperparameters to reproduce the results are given in appendix A. • The artifacts used in the experiments (the Fashion-MNIST dataset and pretrained ConvNet encoder in §3.2) are all publicly available.

Original: • The source code will be released upon acceptance.
Revised: • The source code will be released upon acceptance.

Original: A PPENDIX A A DDITIONAL D ETAILS ON E XPERIMENTAL S ETUP A. M INI -B ATCH C REATION
Revised: A PPENDIX A A DDITIONAL D ETAILS ON E XPERIMENTAL S ETUP A. M INI -B ATCH C REATION

Original: Each mini-batch in our referential game is specified via two parameters: the batch size b and candidate size | C | .
Revised: Each mini-batch in our referential game is specified via two parameters: the batch size b and candidate size | C | .

Original: We first sample b objects from the set of the objects available in the game O .
Revised: We first sample b objects from the set of the objects available in the game O .

Original: Each object in a mini-batch serves as the target object in a round of the game, and we sample | C | −distractors for each target object.
Revised: Each object in a mini-batch serves as the target object in a round of the game, and we sample | C | −distractors for each target object.

Original: Importantly, we sample the objects so that every object in a round of the game has a different object type.
Revised: Importantly, we sample the objects so that every object in a round of the game has a different object type.

Original: A. D ATA P ROCESSING IN THE F ASHION -MNIST GAME
Revised: A. D ATA P ROCESSING IN THE F ASHION -MNIST GAME

Original: The  Fashion-MNIST game (§3.2)is conducted on the level of object type rather than object instance, i.e., the agents have to communicate the classes of the items are on an image rather than those specific items and positions.
Revised: The images used in the Fashion-MNIST game (§3.2) are created by sampling item images from the Fashion-MNIST dataset (Xiao et al., 2017).

Original:  Instead of generating the image and input features on the fly during training, we precompute the image featuresof 3000 instances for each object type and sample inputs from the pre-computed features during training.
Revised: We first take 5,000 images for each item class in the dataset, and then create image objects for the referential game by sampling from the image pool. Instead of generating the image and input features on the fly during training, we precompute 3, images and their features for each object class (i.e., each combination of two items), and they are randomly sampled during training and evaluation.

Original: A. H YPERPARAMETERS
Revised: A. H YPERPARAMETERS

Original: The training setups and hyperparameters are shown in Table 2.
Revised: The training setups and hyperparameters are shown in Table 1.

Original: The hyperparameter tuning is conducted for the weight of entropy loss α , and the scores in the paper are computed from the hyperparameter with the best  generalization accuracy score for each agent. 
Revised: The hyperparameter tuning is conducted for the weight of entropy loss α , and the scores in the paper are computed from the agents with the best 10 generalization accuracy score for each agent. One-hot (4, 4) Fashion-MNIST Speaker message embedding dim

Original: One
Revised: Speaker LSTM decoder hideen dim Speaker Transformer decoder dim Speaker Transformer decoder feed-forward dim Listener message embedding dim

Revised: Listener Bi-LSTM encoder hidden dim

Original: [Table]
Revised: Listener Transformer encoder dim Listener

Revised: Transformer encoder feed-forward

Original: hot
Revised: dim

Revised: Training Batch size

Revised: Max Training steps 15K

Original: [Table]
Revised: [Table]

Revised: B A DDITIONAL R ESULTS

Original: [Table]
Revised: For the configuration of the one-hot game in the main experiments, the number of attributes isand the number of the possible values is 8. We denote this game setting as the one-hot game (8, 2). Here, we show results from the one-hot games with different configurations with more attributes (4, 4) and more values (16, 2). The capacity of the communication channel is set to | V | = 16 , T =and | V | = 32 , T = 2 respectively.

Revised: Also, to accommodate the increased task complexity, we double the model size (i.e., every hidden vector dimension) and set the training batch size to 192 and the max training steps to 30K.

Revised: The results are summarized in Figure 7.

Revised: We generally observe the same trend as discussed in §4.1:

Revised: AT-AT agents outperform their corresponding AT-AT baselines in GenAcc and TopSim.

Revised: The only

Revised: [Figure]

Revised: exception is GenAcc of the AT-AT Transformer agents in the one-hot (4, 4) game.

Revised: The AT-AT agents show significantly lower GenAcc average score than NoAT-NoAT agents (Figure 7e) as well as the

Revised: TrainAcc score (Figure 7d).

Revised: We think that this is caused by the instability of jointly coordinating attention between Speaker and Listener during training.

Revised: This can be particularly problematic with a long message length.

Revised: Yet, the average TopSim score is still higher than the NoAT-NoAT agents (Figure 7f), indicating the inductive bias towards more compositional languages is still effective in this case.

Revised: C T HE D ETAILS OF THE S PEAKER A RCHITECTURES

Revised: In this section, we provide detailed descriptions of the Speaker agents used in the paper.

Revised: [Figure]

Revised: C. S PEAKER

Revised: Speaker has an auto-regressive message decoder that takes the encoded vector(s) of the target object { ˆ o 1 , ..., ˆ o A } as input and generates a multi-symbol message m = ( m 1 , ..., m T ) .

Revised: At each time step t , the decoders embed a previously generated symbol into a vector m t − 1 and produce an output hidden vector h t , which is fed into the output projection layer to predict the next symbol m t .

Revised: The LSTM and Transformer decoders differ in how they transform the symbol vector m t − 1 into the output hidden vector h t .

Revised: We decompose the internal computation into three steps (1) recurrent computation; (2) attention; (3) post-processing, and how each step is implemented.

Revised: C.1. LSTM

Revised: The LSTM decoder is based on the global attention decoder introduced in Luong et al.

Revised: Recurrent computation.

Revised: The LSTM decoder updates the input symbol vector m t − 1 with the contextual information using the LSTM cell (Hochreiter & Schmidhuber, 1997).

Revised: We initialize the memory cell vector with the average of the object vectors 1 A (cid:80) Ai

Original: {+=
+}
Revised: {+=
+}

Revised: ˆ o i followed by a linear transformation and the hidden vector with zero.

Revised: We also apply layer normalization (Ba et al., 2016) to the hidden vector at each time step.

Revised: Attention.

Revised: With the output of the LSTM cell x t , the attention vector is computed over the object vectors { ˆ o 1 , ..., ˆ o A } using the bilinear attention.

Revised: The attention score for each object attribute o i is computed as s it = x

Revised: ⊤ t W b

Revised: ˆ

Revised: o i , where W b is a learnable matrix.

Revised: Then the scores are used to produce the attention weights via the softmax function a it =

Revised: exp( s it ) / (cid:80) j exp( s jt ) .

Revised: Finally, the object vectors are used as the value vectors to produce the output attention vector

Revised: ˆ x t = (cid:80) Ai =1 a it

Revised: ˆ o i .

Revised: Post-processing.

Revised: Finally, the attention vector ˆ x t is concatenated with x t and the vector is projected into the dimension of the object vector followed by the tanh activation function: h t = tanh( W o [ˆ x t ; x t ]) , where W o is a learnable matrix.

Revised: C.1. T RANSFORMER

Revised: The Transformer decoder is based on the original architecture introduced in Vaswani et al.

Revised: We first explain some building blocks repeatedly used in the computation.

Revised: Multi-head QKV Attention.

Revised: The attention used in Transformer takes the query vector x and keyvalue vectors { y 1 , ..., y L } as input and is based on the QKV attention.

Revised: It first project the vectors into query, key, value vector spaces respectively by a linear transformation: q = W q x , k =

Revised: W k y , v = W v y , where W q , W k , W v are learnable matrices.

Revised: Then the attention score is calculated using the scaled dot attention: s it =

Revised: ( q ⊤ t k i ) / √ d , where d is the dimension of the query and key vectors.

Revised: The scores are transformed into the attention weights via the softmax function a it =

Revised: exp( s it ) / (cid:80) j exp( s jt ) .

Revised: Finally, the attention vector is calculated as the weighted sum of the value vectors: ˆ x t = (cid:80) Ai =1 a it v i .

Revised: Transformer further combines the QKV attention with the multi-head mechanism.

Revised: In essence, it divides the query, key and value vectors into sub-spaces with the same dimension, and perform the attention computation as above within each sub-space, and then concatenate each output.

Revised: We denote the attention computation as ˆ x = MultiHeadQKV

Revised: ( x , { y 1 , ..., y L } ) below.

Revised: Sub-layer connection.

Revised: The Transformer architecture combats the gradient vanishing problem using sub-layer connection after each module.

Revised: Let the input or hidden vector of the current time step be x and a module to update the vector as Module, and the sub-layer connection can be described as: ˆ x = SubLayer ( x , Module ( · ))

Revised: =

Revised: LN ( Module ( x ) + x ) , where LN denotes layer normalization.

Revised: Recurrent computation.

Revised: The Transformer decoder updates the input symbol vector m t − 1 with the contextual information using the self-attention mechanism.

Revised: The vector m t − 1 attends to the previous inputs with the multi-head attention mechanism and produce the updated vector: x ′ t =

Revised: MultiHeadQKV ( m t − 1 , { m 1 , ..., m t − 1 } ) .

Revised: Then the sub-layer connection is applied to produce x t =

Revised: LN ( x ′ t + m t − 1 ) .

Revised: Attention.

Revised: The updated vector x t is further updated by attending to the object vectors { ˆ o 1 , ..., ˆ o A } : ˆ x ′ t

Revised: =

Revised: MultiHeadQKV

Revised: ( x t , { ˆ o 1 , ..., o A } ) , followed by the sub-layer connection: ˆ x t = LN (ˆ x ′ t + x t ) .

Revised: Post-processing.

Revised: Finally, the attended vector ˆ x t undergoes the feed-forward layer: h ′ t =

Revised: W 2 ReLU ( W 1 ˆ x t ) , where W 1 and W 2 are learnable matrices.

Revised: The dimension of h ′ t should be the same as the input ˆ x t to apply the sub-layer connection: h t =

Revised: LN (ˆ h ′ t

Revised: + ˆ x t ) .

Revised: [Figure]

Revised: In the main experiments, we used the object encoder that simply averages the attribute vectors for the non-attention baseline, which is equivalent to the model attending to the attribute vectors uniformly (i.e., with the same attention weights).

Revised: Another possible baseline that aggregates multiple attribute vectors into one fixed-sized vector can incorporate the concatenation of the attribute vectors.

Revised: Such method creates an object vector where the attribute information is disentangled across the dimension and thus may lead to better compositionality in the emergent language.

Revised: Here, we replace the object encoder of the NoAT-NoAT agent in the one-hot game with the concatenation-based one.

Original: Rounds
Revised: It firstly projects the input attribute vectors { o 1 , ..., o A } into the dimension of d/A , where d is the dimension of the final object vector, with a learnable matrix parameter. Then, the final object vector ˆ o is derived by concatenating the projected vectors. Figure 9 shows the result from the average-based and concatenation-based object encoder.

Revised: We observe that the concatenation-based encoder outperforms the average-based encoder in TopSim, indicating that having the attribute information disentangled across the vector dimension facilitates learning compositional languages.

Revised: Still, the AT-AT agents perform the best, which shows that having dynamic attention at each symbol generation is more effective.

Revised: E T HE E FFECT OF M ULTI - HEAD A TTENTION

Revised: In the main experiments, we used a single-head attention for the Transformer decoder to facilitate a simpler analysis.

Revised: In this section, we check whether using the multi-head attention affects the performance of the agents.

Revised: We modify the number of heads in the source-target attention of the attentional

Revised: Transformer Speaker and experiment with the non-attention Listener in the one-hot game.

Revised: We could expect that the multi-head attention may improve the performance by adding more flexibility in learning or to the contrary hurt the performance to lose the inductive bias of one-to-one mapping between a symbol and an object attribute.

Original: [Table]
Revised: [Figure]

Revised: From Figure 10, changing the number of heads basically does not affect the performance except for the two-head attention, where GenAcc is significantly lower than the singe-head agent ( p < 0 . 01 ) but the TopSim is significantly higher ( p < 0 . 01 ).

Revised: This possibly stems from some optimization instability.

Revised: Overall, we do not observe significant impact of the multi-head attention in this case.