U NSUPERVISED C IPHER C RACKING U SING D ISCRETE GAN S
Brain
A BSTRACT
This work details CipherGAN, an architecture inspired by CycleGAN used for inferring the underlying cipher mapping given banks of unpaired ciphertext and plaintext.
We demonstrate that CipherGAN is capable of cracking language data enciphered using shift and Vigen ` ere ciphers to a high degree of ﬁdelity and for vocabularies much larger than previously achieved.
We present how CycleGAN can be made compatible with discrete data and train in a stable way.
We then prove that the technique used in CipherGAN avoids the common problem of uninformative discrimination associated with GANs applied to discrete data
I NTRODUCTION
Humans have been encoding messages for secrecy since before the ancient Greeks, and for the same amount of time, have been fascinated with trying to crack these codes using brute-force, frequency analysis, crib-dragging and even espionage.
Simple ciphers have, in the past century, been rendered irrelevant in favor of the more secure encryption schemes enabled by modern computational resources.
However, the question of cipher-cracking remains an interesting problem since it requires an intimate understanding of the structure in a language.
Nearly all automated cipher cracking techniques have had to rely on a human-in-the-loop; grounding the automated techniques in a human’s preexisting knowledge of language to clean up the errors made by simple algorithms such as frequency analysis.
Across a number of domains, the use of hand-crafted features has often been replaced by automatic feature extraction directly from data using end-to-end learning frameworks (Goodfellow et al., 2016).
The question to be addressed is as follows:
Can a neural network be trained to deduce withheld ciphers from unaligned text, without the supplementation of preexisting human knowledge?
The implications for such a general framework would be far-reaching in the ﬁeld of unsupervised translation, where each language can be treated as an enciphering of the other.
The decoding of the Copiale cipher (Knight et al., 2011) stands as an excellent example of the potential for machine learning techniques to decode enciphered texts by treating the problem as language translation.
The
CycleGAN (Zhu et al., 2017) architecture is extremely general and we demonstrate our adaptation,
CipherGAN, is capable of cracking ciphers to an extremely high degree of accuracy.
CipherGAN
Code available requires little or no modiﬁcation to be applied to plaintext and ciphertext banks generated by the user’s cipher of choice.
In addition to presenting a GAN that can crack ciphers, we contribute the following techniques:
• We show how to stabilize CycleGAN training: our CipherGAN achieves good performance in all training runs, compared to approximately 50% of runs for the original CycleGAN.
• We provide a theoretical description and analysis of the uninformative discrimination problem that impacts GANs applied to discrete data.
• We introduce a solution to the above problem by operating in the embedding space and show that it works in practice.
1. S HIFT AND V IGEN ` ERE C IPHERS
The shift and Vigen`ere ciphers are well known historical substitution ciphers.
The earliest known record of a substitution cipher is believed to have dated back to 58 BCE, when Julius Caesar replaced each letter in a message with the letter that was three places further down the alphabet (Singh, 2000).
[Figure]
Using Figure 1, the message “ attackatdawn ” can be encrypted to “ DWWDFNDWGDZQ ”.
This message can be easily deciphered by the intended recipient (who is aware of the particular shift number used) but looks meaningless to a third party.
The shift cipher ensured secure communication between sender and receiver for centuries, until the ninth century polymath Al-Kindi introduced the concept of frequency analysis (Singh, 2000).
He suggested that it would be possible to crack a cipher simply by analyzing the individual characters’ frequencies.
For instance, in English the most frequently occurring letters are ‘ e ’ (12.7%), ‘ t ’ (9.1%) and ‘ a ’ (8.2%); whereas ‘q’, ‘ x ’ and ‘ z ’ each have frequency of less than 1%.
Moreover, the code-breaker can also focus on bigrams of repeated letters; ‘ ss ’, ‘ ee ’, and ‘ oo ’ are the most common in English.
This structure in language provides an exploit of efﬁciency to the code-breaker.
Polyalphabetic substitution ciphers, including the Vigen ` ere cipher, were introduced to inhibit the use of n-gram frequency analysis in determining the cipher mapping.
Instead, the encrypter further scrambles the message by using a separate shift cipher for each element of a key that is tiled to match the length of the plaintext.
Increasing the key length greatly increases the number of possible combinations and thus prevents against basic frequency analysis.
In the mid nineteenth century,
Charles Babbage recognized that the length of the used key could be determined by counting the repetitions and spacing of sequences of letters in the cipher (Singh, 2000).
Using the determined length, we can then apply frequency analysis on the index of the cipher base.
This method makes it possible to break the Vigen`ere cipher, but is very time consuming and requires strong knowledge of the language itself.
There is a rich literature of automated shift-cipher cracking techniques (Ramesh et al., 1993; Forsyth & Safavi-Naini, 1993; Hasinoff, 2003; Knight et al., 2006; Verma et al., 2007;
Raju et al., 2010;
Knight et al., 2011) many of which achieve excellent results which is what one would expect from hand-crafted algorithms targeting speciﬁc ciphers and vocabularies.
Work on automated cracking of polyalphabetic ciphers (Carroll & Martin, 1986; Toemeh & Arumugam, 2008; Omran et al., 2011) has seen similar success on small vocabularies.
It is a difﬁcult matter to compare the results of previous work with our own as their focus ranges from inferring cipher keys (Carroll & Martin, 1986; Ramesh et al., 1993; Omran et al., 2011), to inferring the mappings given limited quantities of ciphertext (determining unicity distance)
(Carroll & Martin, 1986; Ramesh et al., 1993; Hasinoff, 2003; Verma et al., 2007), to analyzing the unicity distance required to solve small percentages of the cipher mappings (i.e. 20% in Carroll & Martin (1986)).
In comparison to these past works, we afford ourselves the advantage of an unconstrained corpus of ciphertext, however, we prescribe ourselves the following constraints: our model is not provided any prior knowledge of vocabulary element frequencies; and, no information about the cipher key is provided.
Another complexity our work must overcome is our signiﬁcantly larger vocabulary sizes; all previous work has addressed vocabularies of approximately 26 characters, while our model is capable of solving word-level ciphers with over 200 distinct vocabulary elements.
As such, our methodology is notably ‘hands-off’ in comparison to previous work and can be easily applied to different forms of cipher, different underlying data and unsupervised text alignment tasks.
1. GAN S AND W ASSERSTEIN GAN S
Generative Adversarial Networks (GANs) are a class of neural network architectures introduced by
Goodfellow et al.
as an alternative to optimizing likelihood under a true data distribution.
Instead, GANs balance the optimization of a generator network which attempts to produce convincing samples from the data distribution, and a discriminator which is trained to distinguish between samples from the true data distribution and the generator’s synthetic samples.
GANs have been shown to produce compelling results in the domain of image generation, but comparatively weak performance in domains using discrete data (discussed in Section 2).
The original GAN discriminator objective as introduced in Goodfellow et al.
(2014) is:
[Equation]
Where F is the generator network and D is the discriminator network.
This loss is vulnerable to the problem of ‘mode collapse’ where the generative distribution collapses to produce a generating distribution with low diversity.
In order to more broadly distribute the mass, the Wasserstein GAN (WGAN) objective (Arjovsky et al., 2017) considers the set of K-Lipschitz discriminator functions
D : X → R and minimizes the earth movers (1st Wasserstein) distance.
The Lipschitz condition is enforced by clipping discriminators weights to fall within a predeﬁned range.
[Equation]
An improved WGAN objective, introduced by Gulrajani et al.
(2017), enforced the Lipschitz condition using a Jacobian regularization term instead of the originally proposed weight-clipping solution.
This resulted in more stable training, avoiding capacity under-use and exploding gradients, and improved network performance over weight-clipping.
[Equation]
Here ˆ X are samples taken along a line between the true data distribution X and the generator’s data distribution X g =
{ F ( z ) |
z ∼ Z} .
1. C YCLE GAN
CycleGAN (Zhu et al., 2017) is a generative adversarial network designed to learn a mapping between two data distributions without supervision.
Three separate works (Zhu et al., 2017; Yi et al., 2017; Liu et al., 2017) share many of the core features we describe below, however, for simplicity we will refer to CycleGAN as the basis for our work as it is the most similar to our model.
It acts on distributions X and Y by using two mapping generators: F : X → Y and G : Y → X ; and two discriminators: D X : X → [0 , 1] and D Y : Y → [0 , 1] .
CycleGAN optimizes the standard GAN loss L GAN :
[Equation]
While also considering a reconstruction loss, or ‘cycle’ loss L cyc :
[Equation]
Taken together the losses are balanced using a hyperparameter λ :
L ( F, G, D X , D Y , X , Y )
=
L GAN ( F, D Y , X , Y ) + L GAN ( G, D X , Y , X ) + λ · L cyc ( F, G, X , Y )
This leads to the training objectives:
[Equation]
CycleGAN uses L cyc to avoid mode collapse by preserving reconstruction of mapping inputs from outputs.
It has demonstrated excellent results in unpaired image translation between two visually similar categories.
Our architecture is the ﬁrst example of this unsupervised learning framework being successfully applied to discrete data such as language.
D ISCRETE GAN S
Applying GANs to discrete data generation is still an open research problem that has seen great interest and development.
The primary difﬁculty with training discrete data generators in a GAN setting is the lack of a gradient through a discrete node in the computation graph.
The alternatives to producing discrete outputs - for instance, generators producing a categorical distribution over discrete elements - are prone to uninformative discrimination (described below), in that, the discriminator may use an optimal discrimination criterion that is unrelated to the correctness of the re-discretized generated data.
In our example of a continuous distribution over discrete elements, the produced samples all lie within the standard simplex ∆ k with dimension k equal to the number of elements in the distribution.
In this case, samples from the true data distribution always lie on a vertex v i of the simplex, while any sub-optimal generator will produce samples within the simplex’s interior ∆ k \{ v 1 , ..., v k } .
In this example, a discriminator which performs uninformative discrimination might evaluate a sample’s membership in the vertices of the simplex as an optimal discrimination criterion, which is entirely uninformative of the correctness of re-discretized samples from the generator.
A number of solutions to training generators with discrete outputs have been proposed:
SeqGAN (Yu et al., 2017) uses the REINFORCE gradient estimate to train the generator; Boundary-seeking GANs (Hjelm et al., 2017) and maximum-likelihood augmented GANs (Che et al., 2017) proposed a gradient approximation with low bias and variance that resembles the REINFORCE (Williams, 1992) estimator.
Gumbel-softmax GANs (Kusner & Hern´andez-Lobato, 2016) replace discrete variables in the simplex with continuous relaxations called Concrete (Maddison et al., 2016) or Gumbel-softmax (Jang et al., 2016) variables;
WGANs (Arjovsky et al., 2017) were suggested as a remedy to the uninformative discrimination problem by ensuring that the discriminator’s rate of change with respect to its input is bound by some constant.
Our work utilizes both the Wasserstein GAN (Gulrajani et al., 2017; Arjovsky et al., 2017) and relaxation of discrete random variables (such as Concrete/Gumbel-softmax).
It has been noted multiple times in implementations of CycleGAN as well as in the original paper itself that the architecture was sensitive to initialization and requires repeat attempts in order to converge to a satisfactory mapping (Bansal & Rathore, 2017; Sari, 2017).
Our architecture suffered the same instability before the
WGAN Jacobian norm regularization term was added to the discriminator’s loss.
In addition, we found that having the discriminator operate over embedding space instead of directly over softmax vectors produced by our generator has improved performance.
Our hypothesis, which is justiﬁed by Proposition 1 below, is that the embedding vectors may act as continuous relaxations of discrete random variables as small, noisy updates are applied throughout training; Proposition 1 asserts that by replacing discrete random variables with continuous ones, our discriminator is prevented from arbitrarily approximating a Dirac delta distribution.
Figure 2 shows simple discriminators trained on the toy task of identify a single vertex of a simplex as true data; it is clear that a lack of regularization leads to the discriminator collapsing to the vertex of the simplex, leaving approximately zero gradient everywhere; while the Jacobian regularization of Wasserstein
GANs leads to the space covered by lines leading from the true data vertex to the generated data having a lower rate of change (note that the gradient is still close to zero in the remaining area of the simplex); and ﬁnally, replacing the discrete random variables of the true data with continuous samples about the vertex results in a much more gradual transition, which is desirable since it provides a stronger gradient signal from which to learn.
Unique to CycleGAN is the auxiliary cycle loss described in Section 1.3.
The effect of this additional objective is the generated samples regularly being forced away from the discriminator’s minimum in favor of a mapping that better-satisﬁes reconstruction.
For instance, it may be the case that the discriminator favors a particular cipher mapping that is not bijective; in this case, the model will receive a strong signal from the cycle loss away from the discriminator’s minimum.
In these cases where the model moves against the gradient it receives from the discriminator it may be the case that this region has near zero curvature (as is visually discernible from Figure 2); this is because the
WGAN curvature regularization (see Equation 3) has not been applied in this region.
‘Curvature’ here refers to the curvature of the discriminator’s output with respect to its input; this curvature determines the strength of the training signal received by the generator.
Low curvature means little information for the generator to improve itself with.
This motivates the beneﬁts of having strong curvature globally, as opposed to linearly between the generators samples and the true data.
Kodali et al.
(2017) proposes regularizing in all directions about the generated samples, which would likely remedy the vanishing gradient in our case as well; for our experiments, the relaxed sampling technique proved effective.
It should also be noted that Luc et al.
(2016) propose something similar to relaxed sampling whereby they replace the ground-truth discrete tokens with a distribution over the vocabulary that distributes some of the mass across the remaining incorrect tokens.
Let us now introduce the deﬁnitions needed for the formal presentation of Proposition 1.
Deﬁnitions.
• (Continuous relaxation of a discrete set).
A continuous relaxation of a discrete set X is a proper, path-connected metric space X satisfying X ⊂ X .
• (Rediscretization function).
A rediscretization function is an injective function R : X → X from a continuous relaxation X of discrete space X satisfying ∀ x ∈ X , ∃ (cid:15) >
0 s.t.
R ≡ x on B (cid:15)
[ x ] .
Note that R deﬁnes an equivalence relation in X .
• (Uninformative Discrimination).
A discriminator D X is said to perform uninformative discrimination under rediscretization function R if: ∃ x ∈ X , ¯ x ∈ X s.t.
( R (¯ x ) = x ) ∧ ( D X ( x ) (cid:54)≈ D X (¯ x )) .
• (Continuous relaxation of a function).
A continuous relaxation of a function over discrete sets F : X → Y is another function F : X → Y (where X , Y are continuous relaxations of X , Y ) such that F is continuous and F ( x ) =
F ( x ) , ∀ x ∈ X .
The following proposition (proved in the Appendix) forms the theoretical basis of the technique.
Proposition 1 (Reliable Fooling Via Relaxation) .
Given:
• discrete spaces X , Y and continuous relaxations X , Y • generators F : X → Y , G : Y → X bijections satisfying F = G −• discrete discriminators D X , D Y both optimal for ﬁxed F, G • rediscretization functions R X , R Y
Suppose: F is approximately volume preserving in a small region about each x ∈ X .
Consequently the same is true for G about each y ∈ Y .
If: during training, we replace discrete random variables from X which lie in the continuous metric space X with samples from regions about them.
Then: the optimal relaxed discriminators D X and D Y have a non-empty region about each x ∈ X and y ∈ Y where they are expected to assign values close to D X ( x ) and D Y ( y ) .
Figure 3 compares a model trained with embedding vectors versus one with only the softmax outputs.
It becomes clear on a harder task, such as Vigen`ere, that the embeddings vastly outperforms softmax in terms of speed of convergence and ﬁnal accuracy; however we found that the simpler task of a shift cipher showed little difference between embeddings and softmax, suggesting an increase in task complexity increases the beneﬁts provided by the stronger gradient signal of embeddings.
M ETHOD 3. C IPHER GAN
GANs applied to text data have yet to produce truly convincing results (Kawthekar et al.).
Previous attempts at discrete sequence generation with GANs have generally utilized a generator outputting a probability distribution over the token space (Gulrajani et al., 2017; Yu et al., 2017; Hjelm et al., 2017).
This leads to the discriminator receiving a sequence of discrete random variables from the data distribution, and a sequence of continuous random variables from the generator distribution; making the task of discrimination trivial and uninformative of the underlying data distribution.
In order to avoid such a scenario, we perform all discrimination within the embedding space by allowing the generator’s output distribution to deﬁne a convex combination of corresponding embeddings.
This leads to the following losses:
[Equation]
We perform an inner product between the embeddings W Emb and the one-hot vectors in x as well as between the embeddings and the softmax vectors produced by generators F and G .
The former is equivalent to a lookup operation over the table of embedding vectors, while the latter is a convex combination between all vectors in the vocabulary.
The embeddings W Emb are trained at each step to minimize L cyc and maximize L GAN , meaning the embeddings are easily mapped from and are easy to discriminate.
As was discussed in Section 2, training with the above loss functions was unstable, with approximately three of every four experiments failing to produce compelling results.
This is a problem we observed with the original CycleGAN horse-zebra experiment, and one that has been noted by multiple re-implementations online (Bansal & Rathore, 2017; Sari, 2017).
We were able to signiﬁcantly increase the stability by training the discriminator loss along with the Lipschitz conditioning term from the improved Wasserstein GAN (Gulrajani et al., 2017)
(see Equationand Fedus et al.
(2017)), resulting in the following loss (DualGAN (Yi et al., 2017) opted to use weight-clipping to enforce the Lipschitz condition):
[Equation]
As a consequence of Proposition 1, discriminators trained on non-stationary embeddings will be unable to approximate Dirac delta distributions to arbitrary accuracy; implying there are dedicated ‘safe-zones’ about members of X where the generator can reliably fool the discriminator and uninformative discrimination is prevented.
In our experiments, we jointly train the embedding vectors as parameters of the model.
The gradient updates applied to these vectors introduces noise between training iterations; we observed that embedding vectors tend to remain in a bounded region after the initial steps of training.
We found
[Table]
that simply replacing the data with embedding vectors had a similar effect to performing the random sampling described in Proposition 1 (see Figure 3).
E XPERIMENTS 4. D ATA
Our experiments use plaintext natural language samples from the Brown English text dataset (Francis & Kucera, 1979).
We generate 2 ∗ batch size plaintext samples, the ﬁrst half are fed as the
CycleGAN’s X distribution and the second half is passed through the cipher of choice and fed as the Y distribution.
For our natural language plaintext data we used the Brown English-language corpus which consists of over one million words in 57340 sentences.
We experiment with both word-level ”Brown-W” and character-level ”Brown-C” vocabularies.
For word-level vocabularies, we control the size of the vocabulary by taking the top k most frequent words and introducing an ‘unknown’ token which we use to replace all words that are not within the taken vocabulary.
We demonstrate our method’s ability to scale to large vocabularies using the word-level vocabularies; more modern enciphering techniques rely on large substitution-boxes (S-boxes) with many (often hundreds of) elements.
4. T RAINING
As in Zhu et al.
we replace the log-likelihood loss with a squared difference loss which was originally introduced by Mao et al.
The original motivation for this replacement was improved stability in training and avoidance of the vanishing gradients problem.
In this work we found the effect on training stability substantial.
[Equation]
Hence, our total loss is:
[Equation]
We adapted the convolutional architecture for the generator and discriminator directly from Zhu et al.
We simply replace all two dimensional convolutions with the one dimension variant and reduce the ﬁlter sizes in our generators to 1 (pointwise convolutions).
Convolutional neural networks have recently been shown to be highly effective on language tasks and can speed up training signiﬁcantly (Zhang & LeCun, 2015; Kalchbrenner et al., 2016; Yu et al., 2017).
Both our generators and discriminators receive a sequence of vectors in embedding space; our generators produce a softmax distribution over the vocabulary, while our discriminator produces a scalar output.
For all our experiments we use a cycle loss with regularization coefﬁcient λ = 1 .
In order to be compatible with the WGAN we replace batch normalization (Ioffe & Szegedy, 2015) with layer normalization (Ba et al., 2016).
We train using the Adam optmizer (Kingma & Ba, 2014) with batch sizeand learning rate 2 e − 4 , β 1 = 0 and β 2 = 0 .
Our learning rate is exponentially warmed up to 2 e − 4 over 2500 steps, and held constant thereafter.
We use learned embedding vectors with
[Table]
[Table] [Table]
dimensions.
The WGAN Lipschitz conditioning parameter was set to α = 10 as was prescribed in
Gulrajani et al.
For the Vigen`ere cipher, positional information is critical to the network being able to perform the mapping.
In order to facilitate this we experimented with adding the timing signal described in
Vaswani et al.
(2017) (”Transformer Timing” in Figure 3) and found that performance increased relative to no explicit timing signal; we found that the best option was concatenating a learned positional embedding vector speciﬁc to each position onto the sequence (”Concat Timing” in Figure 3), this dramatically improved performance, however this means that the architecture can not generalize to sequences longer than those in the training set.
A potential solution to the issue of generalizing to longer sequences would be making a ’soft’ choice at each position for which positional embedding vector to concatenate using a softmax distribution over a set of embedding vectors larger than the expected key length, however, we leave this to future work.
4. D ISCUSSION
Table 2 shows that CipherGAN was able to solve shift ciphers to near ﬂawless accuracy, with all three vocabulary sizes being easily decoded by the model.
CipherGAN performs extremely well on
Vigen`ere, achieving excellent results on the character-level cipher and strong results on the challenging word-level cipher with a vocabulary size of 200.
The vocabulary size of 58 for our character level, containing punctuation and special characters, is more than double what has been previously explored.
In comparison to the original CycleGAN architecture, we found CipherGAN to be extremely consistent in training and notably insensitive to the random initialization of weights; we attribute this stability to the Jacobian norm regularization term.
For both ciphers, the ﬁrst mappings to be correctly determined were those of the most frequently occurring vocabulary elements, suggesting that the network does indeed perform some form of frequency analysis to distinguish outlier frequencies in the two banks of text.
Another interesting observation is that of the mistakes made by the network: the network would frequently confuse punctuation marks with one another, perhaps suggesting that these vocabulary elements’ skip-gram signatures were similar enough to lead to the repeated confusion observed across many training runs.
C ONCLUSION
CipherGAN is a compelling demonstration of the potential generative adversarial networks hold to act on discrete data to solve difﬁcult tasks that rely on an extremely sensitive and nuanced discrimination criterion.
Our work serves to redouble the promise of the CycleGAN architecture for unsupervised alignment tasks for multiple classes of data.
CipherGAN presents an algorithm that is both stable and consistent in training, improving upon past implementations of the CycleGAN architecture.
Our work theoretically motivates – and empirically conﬁrms – the use of continuous relaxations of discrete variables, not only to facilitate the ﬂow of gradients through discrete nodes, but also to prevent the oft-observed phenomena of uninformative discrimination.
CipherGAN is highly general in its structure and can be directly applied to a variety of unsupervised text alignment tasks, without excess burden of adaptation.
On the one hand, CipherGAN is an early step towards the goal of unsupervised translation between languages and has shown excellent performance on the simpliﬁed task of cipher map inference.
On the other hand, the methods we introduce can be used more broadly in the ﬁeld of text generation with adversarial networks.
A CKNOWLEDGMENTS
Our thanks goes to Roger Grosse and Kelvin Shuangjian Zhang for their advice and support throughout.
We also thank Otavio Good and Ian Goodfellow for meaningful early discussions and direction; as well as Michal Wiszniewski for his assistance in developing the code upon which the experiments were run.
This work was made possible thanks to the AI Grant, which provided generous support throughout.
A PPENDIX A A RCHITECTURAL D ETAILS
For both the generator and discriminator architectures below, we assume the network is provided with a sequence of N tokens denoted data laying in a K -simplex.
Therefore data is an N by K matrix.
For simplicity we deﬁne the following notation:
[Equation]
A. G ENERATOR
We deﬁne the following constants:
• fc = 32 : The base ’ﬁlter count‘, or number of ﬁlters in a convolution layer • fs = 1 : The ’ﬁlter size‘, or width of weight kernel used in convolution layers • vs = 1 : The ’vocab size‘, or number of elements in the vocabulary • s = 1 : The stride of the convolution layers • E = 100 : The dimensionality of the embedding vectors • T = 100 : The dimensionality of the concat timing weights
First, we ﬁrst look up embedding vectors corresponding to the observed tokens.
This is performed as a simple inner-product between data and a learning weight matrix of embeddings
W Emb ∈ R
K
× E : x = data ·
[Equation]
Emb
Next, a timing signal is added using either:
• The Transformer method:
[Equation]
• The concat method:
[Equation]
Where W time are trained parameters and [ ·(cid:107)
k · ] denotes concatenation along the k th axis.
Then the generator is deﬁned as follows:
[Equation]
Softmax
[Equation]
A. D ISCRIMINATOR
We deﬁne the following constants:
• fc = 32 : The base ’ﬁlter count‘, or number of ﬁlters in a convolution layer • fs = 15 : The ’ﬁlter size‘, or width of weight kernel used in convolution layers • n = 5 : The depth of the convolutional stack
Similar to the generator, a timing signal is added ﬁrst.
Leading to the following discriminator:
[Equation]
B P ROOF OF P ROPOSITION
Proposition 1 (Reliable Fooling Via Relaxation) .
Given:
• discrete spaces X , Y and continuous relaxations X , Y • generators F : X → Y , G : Y → X bijections satisfying F = G −• discrete discriminators D X , D Y both optimal for ﬁxed F, G • rediscretization functions R X , R Y
Suppose: F is approximately volume preserving in a small region about each x ∈ X .
Consequently the same is true for G about each y ∈ Y .
If: during training, we replace discrete random variables from X which lie in the continuous metric space X with samples from regions about them.
Then: the optimal relaxed discriminators D X and D Y have a non-empty region about each x ∈ X and y ∈ Y where they are expected to assign values close to D X ( x ) and D Y ( y ) .
Proof.
We’ll prove one side of the CipherGAN as the proof for both sides are similar.
Given bijective function between continuous relaxations of X and Y : F : ( X , d X ) → ( Y , d Y ) , where X and Y contain ﬁnite sequences (length n ) of vectors laying on the vertices of the simplex ∆ k , and are supports of data distributions p X , p Y respectively.
Let:
• X
[Equation]
Y
[Equation]
(cid:123)(cid:122) (cid:125) n with k equal to
the
number of elements in our vocabulary.
• the rediscretization function R X : X → X : R X (¯ x ) =
arg min x ∈X d X (¯ x, x ) ; similarly for R Y .
Now, for each x ∈ X consider the inﬁnite set S x with cardinality of the continuum constructed according to:
[Equation]
and
[Equation]
Y
[Equation]
¯ x
[Equation]
= F
[Equation]
x )
Equivalently,
[Equation]
Note.
S x is never of cardinality less than the continuum since the following is implied by the deﬁnitions of R X , S x
and the fact that F is continuous: x ∈ X =
⇒ x ∈ S x ∧ ∃ closed ball B
[Equation]
[ x ] with radius
[Equation]
So, for each element x ∈ X there exists a closed set of points in X which are rediscretized, under
R X , to x .
Since S x is a Borel Set we can sample uniformly from it.
Therefore, during training suppose we replace each element of x ∈ X with a sample ¯ x ∼ S x :
We begin with the discrete objective:
[Equation]
As was noted in Goodfellow et al.
(2014), this objective is optimized in D X : X → [0 , 1] when:
[Equation]
which is undesirable as p X is a sum of Dirac delta distributions p X ( x ) = (cid:80)
x i ∈X δ x i ( x ) and lacks a non-zero gradient to train the generator function with.
Instead, let us consider a continuous relaxation D X : X → [0 , 1] of the discriminator D X and observe where it optimizes.
Suppose ∀ x ∈ X , ∃ (cid:15) x ≥ 0 , ∀ ¯ x ∈ S x
(1 − (cid:15) x ) ≤ |∇ ¯ x F (¯ x ) | ≤ (1 + (cid:15) x ) (6)
That is, suppose F is approximately volume preserving within a small region about each x ∈ X .
Lemma 1.
∀ y ∈ Y , G ( S y )
=
S G ( y )
Proof of Lemma 1.
For all y ∈ Y with G ( y ) = x ⇔ y = F ( x ) :
[Equation]
( S y
[Equation]
G
[Equation]
G
[Equation]
R − 1 X ( G
[Equation]
y
[Equation] [Equation]
Corollary 1.
[Equation]
Proof of Corollary 1.
[Equation]
Corollary 2.
[Equation]
Proof of Corollary 2.
By Equation 6 and Corollary 1:
[Equation]
Corollary 1 leads to the following:
[Equation]
Using Lemma 1 and Corollary
[Equation]
we obtain the following lower-bound of Equation 7:
[Equation]
Which is maximal at:
[Equation]
And similarly, we ﬁnd Equation 7 is upper-bounded by:
[Equation]
Which is maximal in D X at:
[Equation]
Hence, asymptotically as F becomes approximately volume-preserving about each discrete x ∈ X the bounds maximize to the same loss value in the same class of functions E ¯ x ∼ S x
[ D X (¯ x )]
= D X , application of the squeeze theorem concludes the proof.