I NTERNAL -C ONSISTENCY C ONSTRAINTS FOR E MERGENT C OMMUNICATION
Anonymous authors
Paper under double-blind review
A BSTRACT
When communicating, humans rely on internally-consistent language representations.
That is, as speakers, we expect listeners to behave the same way we do when we listen.
This work proposes several methods for encouraging such internalconsistency in dialog agents in an emergent communication setting: shared embeddings, symmetric encoding/decoding, and self-play.
We consider two hypotheses about the effect of internal-consistency constraints: 1) that they improve agents’ ability to refer to unseen referents, and 2) that they improve agents’ ability to generalize across communicative roles (e.g. performing as a speaker despite only being trained as a listener).
While we do not ﬁnd evidence in favor of the former, our results show signiﬁcant support for the latter.
In particular, we show that, when self-consistency is enforced via self-play, agents are able to perform in novel roles as well as if they were trained with direct supervision in those roles.
I NTRODUCTION
Emergent communication is the study of how linguistic protocols evolve when agents are tasked to cooperate.
For example, agents engaged in a simple object retrieval task learn to communicate with one another in order to get the items they want (Lazaridou et al., 2018).
To date, work of this type has each agent assume a conversational role.
Thus, agents are often trained only to speak or only to listen (Lazaridou et al., 2018), or similarily trained to speak using a vocabulary disjoint from the vocabulary it is understands as a listener–e.g. speaking only to ask questions ( “what color?” ) and listening only to comprehend the answer ( “blue” )
(Kottur et al., 2017; Das et al., 2017).
These assumptions are misaligned with how we think about human communication, and with the way we’d like computational models to work in practice.
As humans, not only can we easily shift between roles, we also know that there is inherent symmetry between these roles: we expect others to speak (or listen) similarly to the way we do, and we know that others expect the same of us.
We test if dialog agents that incorporate the symmetry between themselves and their communicative partners learn more generalizable representations than those which do not.
We introduce three modiﬁcations to the agents to encourage that they abide by the “golden rule”: speak/listen as you would want to be spoken/listened to.
Speciﬁcally, these modiﬁcations include self-play training objectives, shared embedding spaces, and symmetric decoding and encoding mechanisms that share parameters.
We test two hypotheses about the effect of the proposed modiﬁcations on emergent communication:
Internal-consistency constraints improve agents’ ability to generalize to unseen items–e.g. training on “red square” and “blue circle” and then testing on “blue square” .
Internal-consistency constraints improve agents’ ability to generalize across communicative roles–e.g. training on “blue” as a listener, and using “blue” as a speaker when testing.
We evaluate the effect of each of the proposed modiﬁcations with two reference game datasets and two model architectures, an RNN model used by Lazaridou et al.
(2018) and a Transformer model.
We ﬁnd no evidence to support that internal-consistency improves generalization to unseen items (Hypothesis 1), but signiﬁcant evidence that these proposed constraints enable models to generalize learned representations across communicative roles (Hypothesis 2), even in the case of where the agent receives no direct training in the target (test) role. All of our code and data are available at bit.ly/internal-consistency-emergent-communication .
Alice
BoB aroma
Of Y
Q x
Alice
BoB aroma
Of Y
Q x
Alice
BoB aroma
Of Y
Q x
Alice
BoB aroma
Of Y
Q x “blue triangle”
Alice
BoB aroma
Of Y
Q x
Alice
BoB aroma Of Y Q x
Alice
BoB aroma
Of Y
Q x
Alice
BoB aroma
Of Y
Q x
E MERGENT C OMMUNICATION VIA R EFERENCE G AMES
Following past work on emergent communication (Lazaridou et al., 2018), we evaluate our models in a cooperative reference game (depicted in Fig. 1)(Lewis, 2008).
A basic reference game consists of two agents and a set of items (each a vector of attribute:value pairs).
One agent (the “speaker”) has a target item in mind, and must describe it to the other agent (the “listener”).
After training, we are primarily interested in the properties and the generalizability of the resulting lexicon : the mapping from symbols in the vocabulary onto items and/or their attributes.
Implemented naively, agents converge to a trivial lexicon which assigns a unique symbolic name to each item in the training set (Kottur et al., 2017).
Thus, a challenge in emergent communication is to build agents which learn a lexicon that maps symbols to attributes or other primitive concepts, so the agents can generalize to novel combinations of attributes at test time.
For example, if trained on items tr shape:circle, color:red s , r shape:square, color:blue su , an ideal lexicon would map each attribute-value pair to a unique word (e.g. word1 =
blue , word2 = circle ) so the agents could refer to an unseen combination ( r shape:circle, color:blue s ) at test time.
Like past work, this paper focuses on evaluating inductive biases that result in lexicons which generalize to novel items.
In addition, we focus on a different type of generalization: generalization across communicative roles.
Prior work has tended to treat these roles as distinct, such that an agent may learn to comprehend “blue” and “circle” perfectly as a listener, and yet be unable to refer to r shape:circle, color:blue s as a speaker.
Thus, we test whether models that are trained in both roles (either with direct supervision, or only via self-play) learn lexicons that not only generalize to novel items but also which can be transferred across roles.
Notation.
The space of possible references is parameterized by the number of attributes n f that describe each item (e.g. color ) and the number of values n v each attribute can take (e.g.{ red, blue }).
Each item o is a bag-of-features vector o P t 0 , 1 u N where N “ n f ¨ n v .
Each index o
i is 1 if o expresses the i th feature value.
The speaker produces a message with symbols from a vocabulary V with length L .
For comparison, we use the best-performing setting | V | “ 100 and L “ 10 from previous work (Lazaridou et al., 2018).
Symbols in V are represented as 1-hot vectors.
In each round of the reference game, we construct x C , r , r y where C is the context (set of item column vectors stacked into a matrix), r is a vector representing the referent, and r is the index of the referent in C .
We uniformly sample k ´ 1 items as distractors to form C “ t o 1 , . . .
o k ´ 1 uYt r u .
The distractors are is sampled randomly each round (in every epoch).
M ODELS
We begin with a general architecture and training objective to underly all of our models (Sections 3.1 and 3.2).
We then introduce three modiﬁcations which can be used to encourage internallyconsistent representations: a self-play training objective, a shared embedding space, and a symmetric decoding and encoding mechanism with shared parameters (Section 3.3) 1 .
3. A RCHITECTURE
Agents contain four modules.
Embedding modules 1)
[Equation]
E ˚ p x q embed items and messages.
When speaking, the decoder module 2) consumes the em-
bedded referent E item p r q and produces a discrete message M P V L .
Next, when listening, the encoder module 3) consumes embedded messages E message p M q P R W ˆ D
and then produces a representation of the referent ˆ r P R D .
Finally, a non-parametric pointing module 4) produces a distribution P p C q over the context by matrix multiplying ˆ r with the embedded context E item p C q .
The decoders emit one symbol at a time, auto-regressively producing ﬁxed-length messages.
The messages are discretized with the straight-through Gumbel Softmax (Jang et al., 2016) as in Mordatch & Abbeel (2018).
This converts a distribution to a one-hot vector while permitting gradients to ﬂow through the operation and enables the agents to be optimized without reinforcement methods.
The Recurrent model uses a LSTM (Hochreiter & Schmidhuber, 1997) decoder when speaking and a LSTM encoder when listening, as in (Lazaridou et al., 2018).
The Transformer model (Vaswani et al., 2017) uses a Transformer Decoder when speaking and a Transformer Encoder to encode when listening.
See Appendix A for implementation details and hyperparameters.
3. T RAINING O BJECTIVES
Speaking S : r , θ Ñ M and listening L : C , M , θ Ñ P p C q are both functions where M P
V L Ă t 0 , 1 u L ˆ| V | is a discrete-valued message with length L , P p C q is a distribution over the items in context, and θ are optimizable parameters.
We optimize the parameters θ A , θ B of agents A, B over a dataset D to select each referent r from among the distractors in its context C by minimizing the negative log likelihood of selecting the correct referent in context (Eq 1).
In our experiments, the speaker modules and the listener modules instantiate the function S and L respectively.
[Equation]
3. I MPOSING I NTERNAL -C ONSISTENCY C ONSTRAINTS
We investigate three internal-consistency constraints, that encourage internally-consistent representations.
Baseline agents consist of two separate sets of parameters, one for listening and one for speaking.
For example, the baseline recurrent model consists of two recurrent models.
This corresponds to the scenario where agents either speak or listen, but not both (Lazaridou et al., 2018).
We introduce a 1) self-play loss for both agents of the same form as Eq. 1 , except the given agent fulﬁlls both roles, encouraging it to speak/listen to others the same way it speaks/listens to itself.
When we use the self-play training objective, we use it for both agents.
Next, 2) shared embedding agents use the same item embeddings and the same message embeddings when listening and speaking.
Finally, 3) symmetric encoding and decoding agents use the same parameters (but different mechanisms) to decode a message when speaking as it does to encode a message when listening.
Parameters are only ever shared between roles within an agent , and never between agents.
D ATASETS
Our evaluation is based on the simple reference game 2 as described in Section 2, played across two datasets.
The datasets, summarized in Table 1, target different aspects of lexical reference.
The ﬁrst, Visual Attributes for Concepts (C ONCEPTS )
Silberer et al.
(2013), is derived from annotated images of actual items (animals, tools, etc).
Thus, the data contains realistic co-occurance patterns: groups of attributes like has-head , has-mouth , and has-snout appears together several times, whereas has-seeds , has-mouth , made-of-metal never co-occur.
The intuition is that a good lexicon will exploit the structure by developing words which refer to groups of frequently co-occurring attributes (e.g. “mammal” ) and will describe unseen referents in terms of these primitive concepts.
The second dataset, S HAPES , is one we create ourselves in contrast with the C ONCEPTS data.
In S HAPES , items correspond to abstract shapes which are exactly describable by their attributes (e.g. blue , shaded , hexagon ).
All the attributes are independent and there is no co-occurence structure to exploit, so a good lexicon should ideally provide a means for uniquely specifying each attribute
’s value independently of the others.
[Table]
R ESULTS
We present experimental results aimed at testing the hypotheses stated in Section 1.
To provide intuition, we frame experiments in terms of two agents, “Alice” (Agent A) and “Bob” (Agent B), who are taking turns asking for and fetching toys.
5. H YPOTHESIS 1: G ENERALIZATION TO NEW ITEMS 5.1. S ETUP
We ﬁrst test whether any of the proposed internal-consistency constraints improve the agents’ ability to generalize to novel items–i.e. items which consist of unseen combinations of features.
Here, we focus on the performance when models are trained and tested within the same communicative role .
This corresponds to the setting that has typically been used in prior work on emergent communication: Alice always speaks in order to ask for toys, Bob always responds by fetching them, and the pair’s success is evaluated in terms of Alice’s ability to describe new toys such that Bob correctly gets them.
For evaluation, we hold out a subset of the value combinations from each dataset to use for testing.
For example, the agents might be trained to refer to tr shape:circle, color:red s , r shape:square, color:blue su and then tested on its ability to refer to r shape:circle, color:blue s .
We compute validation and test accuracies.
5.1. C OMPARISON OF MODEL ARCHITECTURES
Before introducing our internal-consistency constraints, we ﬁrst evaluate our various architectures in this vanilla setting.
Thus, these results serve chieﬂy to calibrate differences between model architectures.
If we see differences between the test conditions, these should be attributed to general architectural advantages associated with implementing these internal-consistency constraints, rather than interpreted as evidence for/against internal-consistency per se .
Table 2 shows the results.
Overall, the transformer architecture outperforms the recurrent architecture, and the transformer outperforms the previously best-reported result for this task (which is only available on the C ONCEPTS data).
We observe no clear trend associated with the shared embedding module (sometimes it helps, sometimes it hurts), but do see a slight positive effect associated with the symmetric transformer.
5.1. E FFECTS OF I NTERNAL -C ONSISTENCY C ONSTRAINTS .
We next look at whether there is an advantage to using the the internal-consistency constraints, even when agents remain in ﬁxed conversational roles.
Intuitively, this corresponds to a scenario in which both Alice and Bob are capable of performing either role (speaking or listening), but nonetheless, they only ever interact within the same routine: Alice only every speaks and Bob only ever listens and fetches items in response.
However, both Alice and Bob can imagine how they would behave if they were to assume the opposite role, and thus, via self-play, each can enforce internal-consistency between their own actions as speaker (listener) and the way they imagine they would respond as listener (speaker). In this manner, although Alice and Bob only ever receive direct feedback in
[Table]
one role, they can still impose internally consistent behavior across both roles. It is conceivable that doing so might improve performance even though each agent remains in a ﬁxed role, either by providing the model with additional information about the task structure, or simply by acting as a regularizer.
Thus, for completeness, we assess whether the internal-consistency constraints provide any advantage to the models in the vanilla emergent communication setting.
Table 3 shows the effect of adding the self-play objective in the ﬁxed-role setting, across architectures and datasets.
The trends are mixed: it appears the additional signal only noises the baseline and symmetric models [Table] whereas the shared embeddings models are able to leverage it effectively.
Thus, the effect is not clear enough to establish conclusively that the internal-consistency constraints help the agents generalize in this ﬁxed-role setting [Table] and in fact it may hurt
[Table]
5. H YPOTHESIS 2: G ENERALIZATION TO NEW ROLES 5.2. S ETUP
We now look at whether internal-consistency improves the agents’ ability to generalize linguistic knowledge across roles.
For example, we can picture the following scenario: Alice is speaking to Bob [Table]
and asks for the “truck” . Bob hands her the doll [Table]
and Alice replies negatively [Table] indicating that what she actually wanted was the truck.
Now, without additional direct supervision, when Bob wants the truck, will he know do use the word “truck” ?
Such a setting is particularly relevant in practical settings, for example when robotic agents must reach high accuracy despite only limited access to human interaction for training.
We consider two versions of this setting, involving different levels of direct supervision (i
[Table] e. interaction with the other agent) as described below.
Training in one role.
Our ﬁrst experimental setting assumes that Alice and Bob each only receive direct training in one role, e.g. Alice only ever speaks to Bob, so Alice only receives feedback on how she is performing as a speaker [Table] and Bob on how he is performing as a listener.
However, both
Alice and Bob are able to practice in the opposite role via self-play.
This setup is analogous to the experiment just discussed in Section 5.1.3.
However, unlike before, Alice and Bob will be tested in the roles opposite of those in which they were trained.
That is, if Alice was trained as a speaker, then she will be tested as a listener (on her ability to correctly identify items to which Bob refers).
Training in both roles.
In our second experimental setting, we assume Alice and Bob enjoy a healthy friendship, in which both take turns speaking and listening to each other, and thus both receive direct supervision in both roles.
However, they do not necessarily receive equal training on every vocabulary item.
Rather, there are some contexts in which Alice only speaks and other contexts in which she only listens.
Intuitively, this corresponds to a scenario in which Alice speaks exclusively about food (while Bob listens), while Bob speaks exclusively about toys (while Alice listens).
We are interested in testing how well Alice is able to speak about toys at test time.
We use the S HAPES dataset 4 to create two training splits, each having the same attributes but covering disjoint sets of values.
For example, the ﬁrst training split ( train-1 ) might have color P {blue, red, yellow} whereas the second training split ( train-2 ) has color P {green, orange, purple} .
We use train-1 to train Alice as speaker and Bob as listener and train-2 to train them in the reverse roles.
We then report performance with Alice as listener and Bob as speaker using a test set that uses the same attribute values as train-1 .
5.2. R ESULTS
Our results for both training conditions are shown in Table 4.
The baseline model (which includes no internal-consistency constraints) performs, unsurprisingly, at chance.
Adding the self-play objective gives improvements across the board.
Again, while seemingly straight forward, this result has promising practical interpretations in settings in which a model has access to only a small amount of interaction.
For example, a human may be willing to train a robot via speaking (pointing and naming items), but not patient enough to train it via listening (responding to the robot’s noisy commands). In such a setting, the ability to massively augment performance via self-play is signiﬁcant.
In addition to the self-play objective, we see that enforcing shared-embedding spaces yields further signiﬁcant performance gains (in the range of 30 percentage points in some cases).
The symmetric constraints on top of self-play and shared embeddings seem to hurt performance in general.
[Table]
[Table]
opposite that in which they are tested. To inspect the additive differences between the internal-consistency constraints, each delta compares the performance of the current column to the previous column. These scores are mean accuracy with 95% conﬁdence range averaged over 5 with different test set samplings (the distractors change).
5. T AKEAWAYS
Overall, when agents can be trained directly in the role in which they are tested, there is no clear evidence that adding internal-consistency constraints improves the ability of agents to generalize to new items.
However, internal-consistency constraints improve performance signiﬁcantly when agents have limited ability to train in a given role.
Speciﬁcally, models which are equipped with selfplay training objectives and shared embedding spaces show superior ability to generalize learned representations across roles, and perform about as well as if they had been trained on the target role.  A NALYSIS In this section we provide additional analyses to highlight the effects of internal-consistency (in particular, self-play) on training efﬁciency and on the emerged protocol.
Here, we use a smaller
S HAPES dataset (see B.1), and reduce the vocabulary size and message length ( | V | “ 10 , L “ 3 ).
6. C AN SELF - PLAY REPLACE DIRECTION SUPERVISION ?
Here we inspect if self-play supplants direct supervision between agents. We consider the setting in which Alice trains with full data as a speaker, but vary the amount of data she has access to as a listener. We then test Alice’s performance as a listener (and vice-versa for Bob as a speaker).
Fig.
2 shows the results, with fraction of the full training data that Alice (Bob) sees as a speaker (listener) shown along the x-axis.
The self-play models without direct supervision perform well: it appears their protocol transfers across roles with out drifting.
This sheds some light on the performance drop between the “one role” and “two role” settings in Section 5.2.2.
where the additional experience in the “two role” setting did not help.
Fig.
2 shows that additional training in the primary role is unnecessary, so it is not surprising that training on disjoint features ( train-2 ) is helpful.
6. D OES SELF - PLAY ENCOURAGE BETTER PROTOCOLS TO EMERGE ?
We measure whether self-play leads to better communication protocols in general.
First, we measure the agents’ speaking and listening capacities separately, using measures proposed by Lowe et al.
; Eccles et al.
Speciﬁcally, positive signaling ( S ` ) measures if the speaker’s messages depend on the features of the referent, and positive listening ( L ` ) measures if the listener’s actions depend on the message 6 .
Table 5 shows that self-play improves the agents’ communication as measured by accuracy as well as these orthogonal metrics. We also ﬁnd that the model architectures and [Table] self-play impact the agents’ lexicons.
The recurrent models produces fewer unique messages than the transformer models (on average 110 versus 300), and often neglect to use all the vocabulary.
Fig. 3 shows that self-play helps the recurrent model use more of the vocabulary, and leads to both the recurrent and transformer models to develop sparser mappings from symbols onto features.  R ELATED W ORK Work in emergent communication (Das et al., 2017; Lazaridou et al., 2018) analyzes agents that develop a shared protocol by playing reference games (Lewis, 2008).
Kottur et al.
(2017) presented results showing that computational models do not learn compositional protocols by default.
Instead, the agents tend to develop brittle protocols that have trouble generalizing to novel items.
Several approaches have been proposed which could encourage models to learn more generalizable representations of language, including compression (Kirby et al., 2015), efﬁciency (Gibson et al., 2019), memory constraints (Kottur et al., 2017), pragmatic constraints (Tomlin & Pavlick, 2018), and positive biases to respond to other agents (Jaques et al., 2018; Eccles et al., 2019).
Some work, like ours, assumes access to symbolic representations of referents and their attributes, whereas others’ are set in pixel-based multi-agent games (Jaques et al., 2018;
Eccles et al., 2019; Das et al., 2018) or multi-agent grid-worlds (Sukhbaatar et al., 2016; Lowe et al., 2019).
Our work also relates to a broader body of work on speaker-listener models, speciﬁcally pragmatically-informed models in which speakers reason recursively about listeners’ beliefs (and vice-versa) (Frank & Goodman, 2012; Goodman & Frank, 2016).
Such models have been used in applications such image captioning (Andreas & Klein, 2016; Yu et al., 2017; Monroe & Potts, 2015), and robotics (Vogel & Jurafsky, 2010; Vogel et al., 2013; Fried et al., 2018), as well as in linguistics and psychology in order to explain complex linguistic inferences (Tessler & Goodman, 2016;
Monroe et al., 2017).
Conceptually, our proposed internal-consistency constraints share something in common with these neural speaker-listener models developed outside of emergent communication.
However, again, past work has tended to assume that a speaker’s mental model of their listener is not necessarily consistent–in fact, it is often assumed explicitly to be inconsistent (Frank & Goodman, 2012)–with the way the speaker themself would behave as a listener.
We note, however, that our proposed model architecture (because it lacks the recursion typical in other pragmatics models) is likely unable to handle the types of higher-level inferences (e.g. implicatures) targeted by the mentioned prior work on computational pragmatics, though this is an interesting avenue to explore.
C ONCLUSION
We propose three methods for encouraging dialog agents to follow “the golden rule”: speak/listen to others as you would expect to be spoken/listened to.
In the emergent communication setting, we ﬁnd that the internal-consistency constraints do not systematically improve models’ generalization to novel items, but both the self-play objective and shared embeddings signiﬁcantly improve performance when agents are tested on roles they were not directly trained for.
In fact, when trained in one role and tested on another, these internal-consistency constraints allow the agents to perform about as well as if they had been trained in the target role.
A I MPLEMENTATION D ETAILS
We use the deep learning framework Pytorch 7 (v1.2.0) to implement our models (and Python 3.7.3).
For reproducibility, all random seeds (random, numpy, torch) are arbitrarily set to 42.
The general architecture, the four modules that comprise each agent are shown in Figure 4.
A. R ECURRENT I MPLEMENTATION
The recurrent model decodes and encodes message as follows: to generate a message, the ﬁrst input is the embedding of a SOS start-of-sentence symbol and the initial hidden state is set as the embedded referent (and the cell memory is all zeroes).
From here, at each step, the outputted hidden state ( P R D ) is projected by the transposed word embeddings ( E ⊺ message P R D ˆ| V | ), and the next word is sampled from this resulting distribution across the vocabulary.
Moving forward, the next input is the embedding of the sampled word, and the hidden state and cell memory are set those emitted at the previous step.
We produce words until the maximum length is reached.
When encoding a message, a learned embedding is set to the ﬁrst hidden state, and the input at each time step is the corresponding embedded word.
The last hidden state is set as the encoding.
In the symmetric variant of this model, the LSTM cell used for encoding and decoding is the same.
[Figure]
A. T RANSFORMER I MPLEMENTATION
The transformer model decodes and encodes message as follows: to generate a message describing the referent auto-regressively, all the embeddings of the words produced so far M and the embedding of a NEXT symbol are concatenated together into a matrix X (Eq. 2).
Next, the transformer decoder consumes this matrix and the referent embedding and produces a contextualized representation of the input matrix (Eq. 3).
The last column vector ˜ X : ,W , which corresponds to the NEXT embedding, is the internal representation of the next word.
The next word m is sampled from the projection of this representation with the transposed word embedding.
More words are produced in this way until the maximum length message is formed.
Producing the i ` 1 th word (so M consists of the ﬁrst i words), works as follows: [Equation]
[Equation]
To encode incoming messages when listening, all the embeddings of the words in the message plus the embedding of a ITEM symbol are concatenated together into a matrix X (Eq. 5).
Then, the transformer encoder is used to produce a contextualized embedding ˜ X
(Eq. 6).
The last column vector ˜ X : ,W , which corresponds to the ITEM embedding, is set as the message encoding.
Note, W is the number of words in each message (and the length of M ).
[Equation]
A. S YMMETRIC A GENTS
For the Symmetric Recurrent Model , a LSTM cell is shared between the encoder and decoder. Otherwise, the recurrent model is unchanged. For the Symmetric Transformer Model , Transformer Encoders and Transformer Decoders have different structures, so to share parameters between them, we have change either how the transformer agent speaks or how it listens.
We opt to replace the Transformer Decoder with Transformer Encoder, and use it to decode messages in-place when speaking.
A.3. S YMMETRIC T RANSFORMER I MPLEMENTATION
The Symmetric Transformer uses the same mechanism for encoding messages when listening as the default transformer model (described directly above).
However, it uses a Transformer Encoder when speaking instead of a Transformer Decode.
When speaking, to produce the next symbol, the embeddings of the i words produced so far, the referent embedding, and the embedding of a NEXT symbol are concatenated together into a matrix X (Eq. 8).
The Transformer Encoder then maps X to a contextualized representation ˜ X (Eq. 9).
Finally, the column vector in X that corresponds to
NEXT , is used to sample the next symbol:
[Equation]
A. H YPER P ARAMETERS
[Table] [Table]
We uniformly sampled 25 hyperparameter conﬁgurations for each model architecture, experiment, and dataset split.
In every case, we ﬁxed the hidden size dimensionality and embedding dimensionality to be the same.
We searched over three different learning rate schedulers: (1) None (or no scheduler, (2) ReduceLROnPlateau with a patience of 25, reduction factor of 0.1, and uses validation accuracy as its measure of progress, and (3) CyclicLR rising from 0.00001 to the given learning rate over 500 batches and then declines towards 0.00001 for the rest of training (10,000 batches).
This is similar to the Noam Update in Vaswani et al.
To save space, we relegate the hyper-parameter selections in our code bit.ly/internal-consistency-emergent-communication – see /lib/hyperparamters.py .
A. T REE R ECONSTRUCTION E RROR
TRE takes two important hyperparameters, an error function and a composition function.
We select the same choices as the author, for what amounts to the same task (producing a discrete message) as detailed in the original paper.
This method requires structured feature representations, so we assume that the features in each item are entirely right-branching.
The composition function is learned, and set the number of update steps to 1000.
The original implementation is at https://github.com/jacobandreas/tre , and our modiﬁcation is at bit.ly/internal-consistency-emergent-communication in the ﬁle ./lib/compositionality.py . B F URTHER ANALYSIS B. S HAPES S MALL
We simplify the S HAPES dataset in order to be able to empirically compute the positive listening and signaling scores, which requires iterating overall possible messages.
In the original version of
S HAPES this is impractical as there would be 50 10 possible messages.
The details of this smaller version of S HAPES detailed in Table 9.
We ﬁx the settings for the recurrent and transformer models as we found that a majority of models across experiments used the same parameters.
See Tables 10, 11.
Furthermore, all results in Sec.are averaged over 5 arbitrary random seeds (both trained and tested) (43, 44, 45, 46, 46).
B. P OSITIVE S IGNALING AND L ISTENING
Positive listening was introduced by Lowe et al.
as Causal Inﬂuence of Communication, and the precursor to positive signaling was introduced by Jaques et al.
We use the deﬁnitions Eccles et al.
(2019) modiﬁed for a one step game for both metrics:
[Equation]
where m is a given message, a are the actions the agent can take, x is state, D KL is the Kuller-bach divergence, I is the mutual information, H is the entropy.
We can compute these quantities without sampling messages because the number of messages is tractable.
In our setting, the game is a single step, and the average policy over actions independent of the message converges to the uniform distribution over actions, as the order of referents is randomized.
Thus we have:
[Equation]
The positive speaking metric is computed over a sampling of the dataset (the distractors are random) as follows as in (Eccles et al., 2019):
[Equation]
where the summations are over all possible messages, x is the given referent, and π p m q is empirically likelihood of the message being produced irrespective of x , and π p m | x q is the likelihood of the given message being produced given the referent x .
We report empirical averages of L ` and S ` over all items in the dataset, also averaged over 5 arbitrary random seeds.
B. A NALYSIS D ETAILS
Figs. 5, 6, 7, 8 show lexicons across random seeds.
See Table 8 for additional results in the vanilla setting for S HAPES -small that were elided for space.
[Table]
[Table]
[Table]
[Table]