The last few years have witnessed dramatic advances in generative models of images that produce near photographic quality imagery of human faces, animals, and natural objects [4, 25, 27]. These models provide an exhaustive characterization of natural image statistics  and represent a significant advance in this domain. However, these advances in image synthesis ignore an important facet of how humans interpret raw visual information , namely that humans seem to exploit structured representations of visual concepts [33, 21]. Structured representations may be readily employed to aid generalization and efficient learning by identifying higher level primitives for conveying visual information  or provide building blocks for creative exploration [21, 20]. This may be best seen in human drawing, where techniques such as gesture drawing  emphasize parsimony for capturing higher level semantics and actions with minimal graphical content .
Our goal is to train a drawing model by presenting it with a large set of example images [16, 13]. To succeed, the model needs to learn both the underlying structure in those images and to generate drawings based on the learned representation 
. In computer vision this is referred to as an “inverse graphics” problem[38, 31, 22, 41]. In our case the output representation is not pixels but rather a sequence of discrete instructions for rendering a drawing on a graphics engine. This poses dual challenges in terms of learning discrete representations for latent variables [56, 23, 37] and performing optimization through a non-differential graphics engine (but see [36, 31]). Previous approaches focused on program synthesis approaches [32, 10] or employing reinforcement and adversarial learning . We instead focus on a subset of this domain where we think we can make progress and improves the generality of the approach.
Font generation represents a 30 year old problem posited as a constrained but diverse domain for understanding higher level perception and creativity 
. Early research attempted to heuristically systematize the creation of fonts for expressing the identity of characters (e.g.a, 2) as well as stylistic elements constituting the “spirit” of a font . Although such work provides great inspiration, the results were limited by a reliance on heuristics and a lack of a learned, structured representation . Subsequent work for learning representations for fonts focused on models with simple parameterizations , template matching , example-based hints , or more recently, learning manifolds for detailed geometric annotations .
We instead focus the problem on generating fonts specified with Scalable Vector Graphics (SVG) – a common file format for fonts, human drawings, designs and illustrations . SVG’s are a compact, scale-invariant representation that may be rendered on most web browsers. SVG’s specify an illustration as a sequence of a higher-level commands paired with numerical arguments (Figure 6, top). We take inspiration from the literature on generative models of images in rasterized pixel space [15, 55]. Such models provide powerful auto-regressive formulations for discrete, sequential data [15, 55] and may be applied to rasterized renderings of drawings . We extend these approaches to the generation of sequences of SVG commands for the inference of individual font characters. The goal of this work is to build a tool to learn a representation for font characters and style that may be extended to other artistic domains [7, 49, 16], or exploited as an intelligent assistant for font creation . In this work, our main contributions are as follows:
Build a generative model for scalable vector graphics (SVG) images and apply this to a large-scale dataset of 14 M font characters.
Demonstrate that the generative model provides a perceptually smooth latent representation for font styles that captures a large amount of diversity and is consistent across individual characters.
Exploit the latent representation from the model to infer complete SVG fontsets from a single (or multiple) characters of a font.
Identify semantically meaningful directions in the latent representation to globally manipulate font style.
2 Related Work
2.1 Generative models of images
Generative models of images have generally followed two distinct directions. Generative adversarial networks  have demonstrated impressive advances [45, 14] over the last few years resulting in models that generate high resolution imagery nearly indistinguishable from real photographs [25, 4].
A second direction has pursued building probabilistic models largely focused on invertible representations [8, 27]. Such models are highly tractable and do not suffer from training instabilities largely attributable to saddle-point optimization . Additionally, such models afford a true probabilistic model in which the quality of the model may be measured with well-characterized objectives such as log-likelihood.
2.2 Autoregressive generative models
One method for vastly improving the quality of generative models with unsupervised objectives is to break the problem of joint prediction into a conditional, sequential prediction task. Each step of the conditional prediction task may be expressed with a sequential model (e.g. ) trained in an autoregressive fashion. Such models are often trained with a teacher-forcing training strategy, but more sophisticated methods may be employed .
2.3 Modeling higher level languages
The task of learning an algorithm from examples has been widely studied. Lines of work vary from directly modeling computation  to learning a hierarchical composition of given computational primitives . Of particular relevance are efforts that learn to infer graphics programs from the visual features they render, often using constructs like variable bindings, loops, or simple conditionals .
The most comparable methods to this work yield impressive results on unsupervised induction of programs usable by a given graphics engine . As their setup is non differentiable, they use the REINFORCE  algorithm to perform adversarial training . This method achieves impressive results despite not relying on labelled paired data. However, it tends to draw over previously-generated drawings, especially later in the generation process. While this could be suitable for modelling the generation of a 32x32 rastered image, SVGs require a certain level of precision in order to scale with few perceptible issues.
2.4 Learning representations for fonts
Previous work has focused on enabling propagation of style between classes by identifying the class and style from high level features of a single character [46, 21, 20] or by finding correspondences between these features of different characters . These features are often simplifications, such as character skeletons, which diminish the flexibility of the methods. Other work directly tackles style manipulation of generated full characters 
, but uses a simple parametric model that allows the user to only adjust parameters like its weight or width.
The most relevant works are those that attempt to learn a manifold of font style. Some unpublished work has explored how probabilistic methods may model pixel-based representations of font style . The model learned semantically-meaningful latent spaces which can manipulate rasterized font images. More directly comparable, recent work learned energy models to capture the relationship between discretized points along the outlines of each character in order to address font generation and extrapolation . This method yields impressive results for extrapolating between very few examples, but is limited by the need of having all characters of a certain class be composed of equivalent shapes Additionally, the model discretely approximates points on a character’s outline which may lead to visual artifacts at larger spatial scales.
We compiled a font dataset composed of M examples across 62 characters (i.e. 0-9, a-z, A-Z), which we term SVG-Fonts. The dataset consists of fonts in a common font format (SFD) 111https://fontforge.github.io, excluding examples where the unicode ID does not match the targeted 62 character set specified above. In spite of the filtering, label noise exists across the roughly 220 K fonts examined.
We employed a one-to-one mapping from SFD to SVG file format using a subset of 4 SVG commands: moveTo, lineTo, cubicBezier and EOS. SVG commands were normalized by starting from the top-most command and ordering in a clockwise direction. In preliminary experiments, we found it advantageous to specify command arguments using relative positioning information. See Appendix for more details of the dataset collection and normalization.
The final dataset consists of a sequence of commands specified in tuples. Each item in the sequence consists of a discrete selection of an SVG command paired with a set of normalized, floating-point numbers specifying command arguments. We restricted the dataset to only 4 SVG command types and examples with fewer then 50 commands to aid learning but these restrictions may be relaxed to represent the complete SVG language. In comparison, note that  restricted inference to 20 actions for generating images. Finally, we partitioned the dataset into M and M examples for training and testing 222We plan to open-source tools to reproduce the construction of a subset of the dataset, as well as code to train the proposed model upon acceptance to a peer-reviewed conference..
3.2 Network Architecture
The proposed model consists of a variational autoencoder (VAE) [30, 16] and an autoregressive SVG decoder implemented in Tensor2Tensor . Figure 7 provides a diagram of the architecture but please see the Appendix for details. Briefly, the VAE consists of a convolutional encoder and decoder paired with instance normalization conditioned on the label (e.g. a, 2, etc.) [9, 43]. The VAE is trained as a class-conditioned autoencoder resulting in a latent code that is largely class-independent . In preliminary experiments, we found that 32 dimensions provides a reasonable balance between expressivity and tractability. Note that the latent code consists of and
- the mean and standard deviation of a multivariate Gaussian that may be sampled at test time.
The SVG decoder consists of 4 stacked LSTMs  trained with dropout [52, 61, 50]. The final layer is a Mixture Density Network (MDN) [3, 15] that may be stochastically sampled at test time. The LSTM receives as input the previous sampled MDN output, concatenated with the discrete class label and the latent style representation . The SVG decoder’s loss is composed of a softmax cross-entropy loss over one-hot SVG commands plus the MDN loss applied to the real-valued arguments.
In principle, the model may be trained end-to-end, but we found it simpler to train the two parts of the model separately. The VAE is trained using pixel renderings of the fonts using the Adam optimizer ()  for epochs. We employ a high value of , and tune the number of free bits using cross-validation . After convergence, the weights of the VAE are frozen, and the SVG decoder is trained to output the SVG commands from the latent representation using teacher forcing .
Note that both the VAE and MDN are probabilistic models that may be sampled many times during evaluation. The results shown here are the selected best out of 10 samples. Please see Appendix for modeling, training and evaluation details.
We compiled a font dataset consisting of 14 M examples. Individual font characters were normalized and converted into SVG format for training and evaluation. We trained a VAE and SVG decoder over epochs of the data and evaluated the results on a hold-out test split. Figures 6 and 8 show selected results from the trained model, but please see Appendix (Figures 17 and 18) for more exhaustive samples highlighting successes and failures. What follows is an analysis of the representational ability of the model to learn and generate SVG specified fonts.
4.1 Learning a smooth, latent representation of font style
We first ask whether the proposed model may learn a latent representation for font style that is perceptually smooth and interpretable. To address this question, we visualize the 32-dimensional font-style for 1 M examples from the training set and reduce the dimensionality to 2 using UMAP . We discretize this 2D space and visualize the pixel-based decoding of the mean within each grid location (Figure 9). The purple boxes shows two separate locations of this manifold, where we note the smooth transitions of the characters: (A) represents a non-italics region, while (B) represents an italics one. Further, local directions within these regions also reveal visual semantics: within (A), from left-to-right we note a change in the amount of serif, while top-to-bottom highlights a change in boldness.
Next, we examine whether this smooth space translates into perceptually meaningful decodings of SVGs. We visualize linear interpolations between for pairs of SVGs from the dataset (Figure 9, 1-6). Note the smooth transition between the decoded SVGs, despite the fact that each SVG decoding is composed of a multitude of different commands. For instance, note that in the top row, each SVG is composed of 15-30 commands even though the perceptual representation appears quite smooth.
4.2 Exploiting the latent representation for style propagation
and measure the variance ofover all generated characters within a font. Lower variance in indicates a more visually consistent font style. Each dot corresponds to the observed variance in when conditioned on or characters. Note that most fonts contain higher consistency (i.e. lower variance) when conditioned on more characters.
Because the VAE is conditioned on the class label, we expect that the latent representation would only encode the font style with minimal class information . We wish to exploit this model structure to perform style propagation across fonts. In particular, we ask whether a single character from a font set is sufficient to infer the rest of the font set in a visually plausible manner [46, 20].
To perform this task, we calculate the latent representation for a single character and condition the SVG decoder on as well as the label for all other font characters (i.e. 0-9, a-z, A-Z). Figure 10 shows the results of this experiment. For each row, is calculated from the character in the red box. The other characters in that row are generated from the SVG decoder conditioned on .
We observe a perceptually-similar style consistently within each row [46, 20]. Note that there was no requirement during training that the same point in latent space would correspond to a perceptually similar character across labels – that is, the consistency across class labels was learned in an unsupervised manner [46, 20]. Thus, a single value of seems to correspond to a perceptually-similar set of characters that resembles a plausible fontset.
Additionally, we observe a large amount of style variety across rows (i.e. different ) in Figure 10. The variety indicates that the latent space is able to learn and capture a large diversity of styles observed in the training set as observed in Figure 9.
Finally, we also note that for a given column the decoded glyph does indeed belong to the class that was supplied to the SVG decoder. These results indicate that encodes style information consistently across different character labels, and that the proposed model largely disentangles class label from style.
A natural extension to this experiment is to ask if we could systematically improve the quality of style propagation by employing more then a single character. We address this question by calculating the latent representation for multiple characters and employ the average for style propagation to a new set of characters (Figure 11). We observe a systematic improvement in both style consistency and quality of individual icon outputs as one conditions on increasing numbers of characters.
To quantify this improvement in style consistency, we render the generated characters and calculate the associated style for each character. If the method of style propagation were perfectly self-consistent, we would expect that the across all generated characters would be identical. If, however, the style propagation were not consistent, the inferred would vary across each of the generated characters. To calculate the observed improvement, we measure the variance of across all generated characters for each of 19 fonts explored with this technique when conditioned on on or characters (Figure 11, bottom). Indeed, we observe that conditioning on more characters generally decreases the variance of the generated styles, indicating that this procedure improves style consistency. Taken together, we suspect that these results on style progagation suggest a potential direction for providing iterative feedback to humans for synthesizing new fonts (see Discussion).
4.3 Building style analogies with the learned representation
Given that the latent style is perceptually smooth and aligned across class labels, we next ask if we may find semantically meaningful directions in this latent space. In particular, we ask whether these semantically meaningful directions may permit global manipulations of font style.
Inspired by the work on word vectors , we ask whether one may identify analogies for organizing the space of font styles (Figure 12, top). To address this question, we select positive and negative examples for semantic concepts of organizing fonts (e.g. bold, italics, condensed) and identify regions in latent space corresponding to the presence or absence of this concept (Figure 12, left, blue and red, respectively). We compute the average and , and define the concept direction .
We test if these directions are meaningful by taking an example font style from the dataset (Figure 12, right, yellow), and adding (or subtracting) the concept vector scaled by some parameter . Finally, we compute the SVG decodings for across a range of .
Figure 12 (right) shows the resulting fonts. Note that across the three properties examined, we observe a smooth interpolation in the direction of the concept modeled (e.g.: first row v becomes increasingly bold from left to right). We take these results to indicate that one may interpret semantically meaningful directions in the latent space. Additionally, these results indicate that one may find directions in the latent space to globally manipulate font style.
4.4 Quantifying the quality of the learned representations
Almost all of the results presented have been assessed qualitatively. This is largely due to the fact that the quality of the results are assessed based on human judgements of aesthetics. In this section, we attempt to provide some quantitative assessment of the quality of the proposed model.
Figure (a)a (top) shows the training dynamics of the model as measured by the overall training objective. Over the course of training epochs, we find that the model does indeed improve in terms of likelihood and plateaus in performance. Furthermore, the resulting model does not overfit on the training set in any significant manner as measured by the log-likelihood.
Figure (a)a (bottom) shows the mean negative log likelihoods for the examples in each class of the dataset. There is a small but systematic spread in average likelihood across classes. This is consistent with our qualitative results, where certain classes would consistently yield lower quality SVG decodings than others (e.g. 7 in Figure 10).
We can characterize the situations where the model performs best, and some possible causes for its improved performance. Figure (b)b shows the negative log likelihoods of examples from the test set of a given class, as a function of their sequence lengths. With longer sequences, the variance of log likelihoods increase. For the best performing class (8, top) the loss values also trend downwards, whereas for the worst performing (7, bottom), the trend stays relatively level. This means that the model had a harder time reliably learning characters especially with longer sequence lengths.
Finally, in order to see what makes a given character hard or easy to learn, we examine test examples that achieved high and low loss, at different sequence lengths. Figure LABEL:fig6:c reveals that for any class characters with high loss are generally highly stylized, regardless of their sequence lengths (red, blue), whereas easier to learn characters are more commonly found styles (yellow, green).
4.5 Limitations of working with a learned, stochastic, sequential representation
Given the systematic variability in the model performance across class label and sequence length, we next examine how specific features of the modeling choices may lead to these failures. An exhaustive set of examples of model failures is highlighted in in Figure 18 of the Appendix. We discuss below two common modes for failure due to the sequential, stochastic nature of the generative model.
At each stochastic sampling step, the proposed model may select a low likelihood decision. Figure 16a highlights how a mistake in drawing 3 early on leads to a series of errors that the model was not able to error correct. Likewise, Figure LABEL:fig7:a shows disconnected start and end points in drawing 6 caused by the accumulation of errors over time steps. Both of these errors may be remedied through better training schedules that attempt to teach forms of error correction , but please see Discussion.
A second systematic limitation is reflected in the uncertainty captured within the model. Namely, the proposed architecture contains some notion of confidence in its own predictions as measured by the variance in the VAE latent representation. We visualize the confidence by color-coding the UMAP representation for the latent style by (Figure 16b, right). Lighter green colors indicate high model confidence reflected by lower VAE variance. Areas of high confidence show sharp outputs and decode higher quality SVGs (Figure 16b, purple). Conversely, areas with lower confidence correspond to areas with higher label noise or more stylized characters. These regions of latent space decode lower quality SVGs (Figure 16b, yellow). Addressing these systematic limitations is a modeling challenge for building next generation generative models for vector graphics (see Discussion).
In the work we presented a generative model for vector graphics. This model has the benefit of providing a scale-invariant representation for imagery whose latent representation may be systematically manipulated and exploited to perform style propagation. We demonstrate these results on a large dataset of fonts and highlight the limitations of a sequential, stochastic model for capturing the statistical dependencies and richness of this dataset. Even in its present form, the current model may be employed as an assistive agent for helping humans design fonts in a more time-efficient manner [6, 46]. For example, a human may design a small set of characters and employ style propagation to synthesize the remaining set of characters (Figure 10, 11).
An immediate question is how to build better-performing models for vector graphics. Immediate opportunities include new attention-based architectures  or potentially some form of adversarial training . Improving the model training to afford the opportunity for error correction may provide further gains .
A second direction is to employ this model architecture on other SVG vector graphics datasets. Examples include icons datasets  or human drawings [49, 16]. Such datasets reveal additional challenges above-and-beyond the fonts explored in this work as the SVG drawings encompass a larger amount of diversity and drawings containing larger numbers of strokes in a sequence. Additionally, employing color, brush stroke and other tools in illustration as a predicted features offers new and interesting directions for increasing the expressivity of the learned models.
We’d like to thank the following people: Diederik Kingma, Benjamin Caine, Trevor Gale, Sam Greydanus, Keren Gu, and Colin Raffel for discussions and feedback; Monica Dinculescu and Shan Carter for insights from designers’ perspective; Ryan Sepassi for technical help using Tensor2Tensor; Jason Schwarz for technical help using UMAP; Joshua Morton for infrastructure help; Yaroslav Bulatov, Yi Zhang, and Vincent Vanhoucke for help with the dataset; and the Google Brain and the AI Residency teams.
S. Bengio, O. Vinyals, N. Jaitly, and N. Shazeer.
Scheduled sampling for sequence prediction with recurrent neural networks.In Advances in Neural Information Processing Systems, pages 1171–1179, 2015.
-  Y. Bengio, A. Courville, and P. Vincent. Representation learning: A review and new perspectives. IEEE Trans. Pattern Anal. Mach. Intell., 35(8), 2013.
-  C. M. Bishop. Mixture density networks. Technical report, Citeseer, 1994.
-  A. Brock, J. Donahue, and K. Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018.
-  N. D. Campbell and J. Kautz. Learning a manifold of fonts. ACM Transactions on Graphics (TOG), 33(4):91, 2014.
S. Carter and M. Nielsen.
Using artificial intelligence to augment human intelligence.Distill, 2017. https://distill.pub/2017/aia.
-  L. Clouâtre and M. Demers. Figr: Few-shot image generation with reptile. arXiv preprint arXiv:1901.02199, 2019.
-  L. Dinh, J. Sohl-Dickstein, and S. Bengio. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.
-  V. Dumoulin, J. Shlens, and M. Kudlur. A learned representation for artistic style. Proc. of ICLR, 2, 2017.
-  K. Ellis, D. Ritchie, A. Solar-Lezama, and J. Tenenbaum. Learning to infer graphics programs from hand-drawn images. In Advances in Neural Information Processing Systems, pages 6062–6071, 2018.
-  J. Ferraiolo. Scalable vector graphics (SVG) 1.0 specification.
-  R. Fox, R. Shin, S. Krishnan, K. Goldberg, D. Song, and I. Stoica. Parametrized hierarchical procedures for neural programming. ICLR 2018, 2018.
-  Y. Ganin, T. Kulkarni, I. Babuschkin, S. Eslami, and O. Vinyals. Synthesizing programs for images using reinforced adversarial learning. arXiv preprint arXiv:1804.01118, 2018.
-  I. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014.
-  A. Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013.
-  D. Ha and D. Eck. A neural representation of sketch drawings. arXiv preprint arXiv:1704.03477, 2017.
K. He, X. Zhang, S. Ren, and J. Sun.
Delving deep into rectifiers: Surpassing human-level performance on imagenet classification.In Proceedings of the IEEE international conference on computer vision, pages 1026–1034, 2015.
-  I. Higgins, L. Matthey, A. Pal, C. Burgess, X. Glorot, M. Botvinick, S. Mohamed, and A. Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. In International Conference on Learning Representations, 2017.
-  S. Hochreiter and J. Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.
-  D. Hofstadter and G. McGraw. Letter spirit: An emergent model of the perception and creation of alphabetic style. 1993.
-  D. R. Hofstadter. Fluid concepts and creative analogies: Computer models of the fundamental mechanisms of thought. Basic books, 1995.
V. Jampani, S. Nowozin, M. Loper, and P. V. Gehler.
The informed sampler: A discriminative approach to bayesian inference in generative computer vision models.Computer Vision and Image Understanding, 136:32–44, 2015.
-  E. Jang, S. Gu, and B. Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016.
-  Ł. Kaiser and I. Sutskever. Neural gpus learn algorithms. arXiv preprint arXiv:1511.08228, 2015.
-  T. Karras, S. Laine, and T. Aila. A style-based generator architecture for generative adversarial networks. arXiv preprint arXiv:1812.04948, 2018.
-  D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
-  D. P. Kingma and P. Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In Advances in Neural Information Processing Systems, pages 10236–10245, 2018.
-  D. P. Kingma, S. Mohamed, D. J. Rezende, and M. Welling. Semi-supervised learning with deep generative models. In Advances in neural information processing systems, pages 3581–3589, 2014.
-  D. P. Kingma, T. Salimans, R. Jozefowicz, X. Chen, I. Sutskever, and M. Welling. Improved variational inference with inverse autoregressive flow. In Advances in neural information processing systems, pages 4743–4751, 2016.
-  D. P. Kingma and M. Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
-  T. D. Kulkarni, W. F. Whitney, P. Kohli, and J. Tenenbaum. Deep convolutional inverse graphics network. In Advances in neural information processing systems, pages 2539–2547, 2015.
-  B. M. Lake, R. Salakhutdinov, and J. B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.
-  B. M. Lake, T. D. Ullman, J. B. Tenenbaum, and S. J. Gershman. Building machines that learn and think like people. Behavioral and Brain Sciences, 40, 2017.
-  V. M. Lau. Learning by example for parametric font design. In ACM SIGGRAPH ASIA 2009 Posters, page 5. ACM, 2009.
B. Loh and T. White.
Spacesheets: Interactive latent space exploration through a
Workshop on Machine Learning for Creativity and Design, 2018.
-  M. M. Loper and M. J. Black. Opendr: An approximate differentiable renderer. In European Conference on Computer Vision, pages 154–169. Springer, 2014.
-  C. J. Maddison, A. Mnih, and Y. W. Teh. The concrete distribution: A continuous relaxation of discrete random variables. arXiv preprint arXiv:1611.00712, 2016.
-  V. K. Mansinghka, T. D. Kulkarni, Y. N. Perov, and J. Tenenbaum. Approximate bayesian image interpretation using generative probabilistic graphics programs. In Advances in Neural Information Processing Systems, pages 1520–1528, 2013.
-  L. McInnes, J. Healy, and J. Melville. Umap: Uniform manifold approximation and projection for dimension reduction. arXiv preprint arXiv:1802.03426, 2018.
-  T. Mikolov, I. Sutskever, K. Chen, G. S. Corrado, and J. Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pages 3111–3119, 2013.
-  V. Nair, J. Susskind, and G. E. Hinton. Analysis-by-synthesis by learning to invert generative black boxes. In International Conference on Artificial Neural Networks, pages 971–981. Springer, 2008.
-  A. v. d. Oord, S. Dieleman, H. Zen, K. Simonyan, O. Vinyals, A. Graves, N. Kalchbrenner, A. Senior, and K. Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016.
-  E. Perez, F. Strub, H. De Vries, V. Dumoulin, and A. Courville. Film: Visual reasoning with a general conditioning layer. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
-  P. Picasso. The bull (le taureau), states i-x, 1946. Museum of Modern Art (MoMA). Mrs. Gilbert W. Chapman Fund. Lithograph.
-  A. Radford, L. Metz, and S. Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
-  J. A. Rehling. Letter spirit(part two): modeling creativity in a visual domain. Indiana University, 2001.
-  D. Reisberg and S. Snavely. Cognition: Exploring the science of the mind. 2010.
-  D. J. Rezende, S. Mohamed, and D. Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014.
-  P. Sangkloy, N. Burnell, C. Ham, and J. Hays. The sketchy database: Learning to retrieve badly drawn bunnies. ACM Transactions on Graphics (proceedings of SIGGRAPH), 2016.
-  S. Semeniuta, A. Severyn, and E. Barth. Recurrent dropout without memory loss. arXiv preprint arXiv:1603.05118, 2016.
-  E. P. Simoncelli and B. A. Olshausen. Natural image statistics and neural representation. Annual review of neuroscience, 24(1):1193–1216, 2001.
-  N. Srivastava, G. Hinton, A. Krizhevsky, I. Sutskever, and R. Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.
-  W. Stanchfield. Gesture drawing for animation. Washington: Leo Brodie, 2007.
-  R. Suveeranont and T. Igarashi. Example-based automatic font generation. In International Symposium on Smart Graphics, pages 127–138. Springer, 2010.
-  A. Van den Oord, N. Kalchbrenner, L. Espeholt, O. Vinyals, A. Graves, et al. Conditional image generation with pixelcnn decoders. In Advances in Neural Information Processing Systems, pages 4790–4798, 2016.
-  A. van den Oord, O. Vinyals, et al. Neural discrete representation learning. In Advances in Neural Information Processing Systems, pages 6306–6315, 2017.
-  A. Vaswani, S. Bengio, E. Brevdo, F. Chollet, A. N. Gomez, S. Gouws, L. Jones, Ł. Kaiser, N. Kalchbrenner, N. Parmar, et al. Tensor2tensor for neural machine translation. arXiv preprint arXiv:1803.07416, 2018.
-  A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pages 5998–6008, 2017.
R. J. Williams.
Simple statistical gradient-following algorithms for connectionist reinforcement learning.Machine learning, 8(3-4):229–256, 1992.
-  R. J. Williams and D. Zipser. A learning algorithm for continually running fully recurrent neural networks. Neural computation, 1(2):270–280, 1989.
-  W. Zaremba, I. Sutskever, and O. Vinyals. Recurrent neural network regularization. arXiv preprint arXiv:1409.2329, 2014.
-  D. E. Zongker, G. Wade, and D. H. Salesin. Example-based hinting of true type fonts. In Proceedings of the 27th annual conference on Computer graphics and interactive techniques, pages 411–416. ACM Press/Addison-Wesley Publishing Co., 2000.
Appendix A Appendix
a.1 Dataset details
We collected a total of font characters (, per class) in a common format (SFD), while retaining only characters whose unicode id corresponded to the classes 0-9, a-z, A-Z. Filtering by unicode id is imperfect because many icons intentionally declare an id such that equivalent characters can be rendered in that font style (e.g.: 七 sometimes declares the unicode id normally reserved for 7).
We then convert the SFD icons into SVG. The SVG format can be composed of many elements (square, circle, etc). The most expressive of these is the path element whose main attribute is a sequence of commands, each requiring a varying number of arguments (lineTo: 1 argument, cubicBezierCurve: 3 arguments, etc.). An SVG can contain multiple elements but we found that SFD fonts can be modelled with a single path and a subset of its commands (moveTo, lineTo, cubicBezierCurve, EOS). This motivates our method to model SVGs as a single sequence of commands.
In order to aid learning, we filter out characters with over 50 commands. We also found it crucial to use relative positioning in the arguments of each command. Additionally, we re-scale the arguments of all icons to ensure that most real-values in the dataset will lie in similar ranges. This process preserves size differences between icons. Finally, we standardize the command ordering within a path such that each shape begins and ends at its top-most point and the curves always start by going clockwise. We found that setting this prior was important to remove any ambiguity regarding where the SVG decoder should start drawing from and which direction (information which the image encoder would not be able to provide).
When rendering the SVGs as x pixel images, we pick a render region that captures tails and descenders that go under the character’s baseline. Because relative size differences between fonts are still present, this process is also imperfect: zoom out too little and many characters will still go outside the rendered image, zoom out too much and most characters will be too small for important style differences to be salient.
Lastly, we convert the SVG path into a vector format suitable for training a neural network model: each character is represented by a sequence of commands, each consisting of tuples with: 1) a one-hot encoding of command type (moveTo, lineTo, etc.) and 2) a normalized representation of the command’s arguments (e.g.: x, y positions). Note that for this dataset we only use 4 commands (including EOS), but this representation can easily be extended for any SVG icon that use any or all of the commands in the SVG path language.
a.2 Details of network architecture
Our model is composed of two separate substructures: a convolutional variational autoencoder and an auto-regressive SVG decoder. The model was implemented and trained with Tensor2Tensor .
, and a ReLU activation. Its output is arepresentation of the input image. At training time, is sampled using the reparameterization trick [30, 48]. At test time, we simply use . The image decoder is an approximate mirror image of the encoder, with transposed convolutions in place of the convolutions. All convolutional-type layers have SAMEpadding. CIN layers were conditioned on the icon’s class.
|Operations||Kernel, Stride||Output Dim|
keep-probability. The decoder’s topmost layer consists of a Mixture Density Network (MDN)[3, 15]. It’s hidden state is initialized by conditioning on . At each time-step, the LSTM receives as input the previous time-step’s sampled MDN output, the character’s class and the representation. The total number of parameters is .
a.3 Training details
The optimization objective of the image VAE is the log-likelihood reconstruction loss and the KL loss applied to with KL-beta . We use Kingma et al’s  trick with free bits ( per dimension of ). The model is trained with batch size .
The SVG decoder’s loss is composed of a softmax cross-entropy loss between the one-hot command-type encoding, added to the MDN loss applied to the real-valued arguments. We found it useful to scale the softmax cross-entropy loss by when training with this mixed loss. We trained this model with teacher forcing and used batch size .
a.4 Visualization details
The dimensionality reduction algorithm used for visualizing the latent space is UMAP . We fit the activations of M examples from the dataset into
UMAP components, using the cosine similarity metric, with a minimum distance of, and nearest neighbors. After fitting, we discretize the 2D space into discrete buckets and decode the average in each grid cell with the image decoder.
a.5 Samples from generated font sets
Figures 6, 9, 10, 12 and 16 contained selected examples to highlight the successes and failures of the model as well as demonstrate various results. To provide the reader with a more complete understanding of the model performance, below we provide additional samples from the model highlighting successes (Figure 17) and failures (Figure 18). As before, results shown are selected best out of 10 samples.