Add files using upload-large-folder tool

parse/dev/AJg35fkqOPA/AJg35fkqOPA_content_list.json

@@ -0,0 +1,1387 @@
+[
+    {
+        "type": "text",
+        "text": "TEXT-DRIVEN IMAGE MANIPULATION VIA SEMANTIC-AWARE KNOWLEDGE TRANSFER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            704,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semantic-level facial attribute transfer is a special task to edit facial attribute, when reference images are viewed as conditions to control the image editing. In order to achieve better performance, semantic-level facial attribute transfer needs to fulfil two requirements: (1) specific attributes extracted from reference face should be precisely transferred to target face; (2) irrelevant information should be completely retained after transferring. Some existing methods locate and modify local support regions of facial images, which are not effective when editing global attributes; the other methods disentangle the latent code as different attributerelevant parts, which may transfer redundant knowledge to target faces. In this paper, we first propose a novel text-driven directional latent mapping network with semantic direction consistency (SDC) constrain to explore the latent semantic space for effective attribute editing, leveraging the semantic-aware knowledge of Contrastive Language-Image Pre-training (CLIP) model as guidance. This latent space manipulation strategy is designed to disentangle the facial attribute, removing the redundant knowledge in the transfer process. And on this basis, a novel attribute transfer method, named semantic directional decomposition network (SDD-Net), is proposed to achieve semantic-level facial attribute transfer by latent semantic direction decomposition, improving the interpretability and editability of our method. Extensive experiments on CelebA-HQ dataset show that our method achieves impressive performance over the state-of-the-art methods. ",
+        "bbox": [
+            233,
+            266,
+            764,
+            544
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            571,
+            334,
+            587
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) have revolutionized a variety of fields due to its powerful ability to generate realistic and meaningful outputs. Recent works (Jahanian et al., 2019; He et al., 2019; Goetschalckx et al., 2019) have shown that deep generative models can capture real-world data distribution, and encode them into a semantically-rich latent space. Inspired by this, a lot of tasks draw their attention on the latent space manipulation, including image enhancement (Ledig et al., 2017; Yang et al., 2021b), editing (Shen et al., 2020; Hark ¨ onen ¨ et al., 2020; Patashnik et al., 2021), and discriminative tasks (Nitzan et al., 2021; Xu et al., 2021). ",
+        "bbox": [
+            174,
+            603,
+            825,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With the tremendous success of deep generative models, facial attribute editing (Yeh et al., 2017; Liu et al., 2019; He et al., 2020; Dorta et al., 2020), aiming to edit the specific attributes of the target facial image, has become topical. As a special case of facial attribute editing, facial attribute transfer (Xiao et al., 2018; Lin et al., 2018; Yin et al., 2019; Choi et al., 2018; 2020) uses knowledge from reference image as a condition to edit the corresponding attribute from the target image. In order to ensure that the manipulated facial image meets the requirements and interests, facial attribute transfer task tackles two challenges simultaneously: (1) editing relevance: the relevant attribute should be edited precisely according to the given condition; and (2) keeping irrelevance: the irrelevant part (e.g., identify information, background, or other attributes) should not be modified during attribute transfer. Due to strong entanglement of the attributes, meeting both requirements is an intractable task. For example, without fully disentanglement, transferring the “smile” attribute to the target facial image may cause that, another irrelevant but coupled attribute, e.g. “cheek color” attribute, would be changed during editing. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In view of the above issues, recently a variety of methods explore the attribute disentanglement in two ways. Some methods (He et al., 2020; Kwak et al., 2020) resort to the way of spatial attention detection, which disentangle the attribute by searching specific support region spatially and only manipulate the image in such a confined area. Obviously, these methods totally ignore the facial details beyond the support region when the edited attribute is a global attribute, such as “smile” or “age”. Meanwhile, other methods (Shen et al., 2020; Yang et al., 2021a; Patashnik et al., 2021) pay attention to the latent space factorization through pre-trained GAN. These methods employ the high-level semantic information as guidance to manipulate image in latent spaces, which are more suitable to handle both global and local attribute editing. However, owing to over-coupled semantic features, these methods are hard to manipulate specific attribute without powerful supervision. ",
+        "bbox": [
+            174,
+            896,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To overcome the problems mentioned above, we explore the latent semantic space for disentangled attribute editing, and apply the discovered manipulation method to facial attribute transfer task. As for attribute editing task, in order to disentangle and edit the attribute specified by the text prompt, we design the directional latent mapping network, which leverages semantic direction consistency (SDC) loss to constrain the manipulation in the CLIP-space (Radford et al., 2021). The key idea of the SDC loss is employing the change direction of semantic feature to estimate the latent manipulation. Furthermore, in order to apply this effective editing method to facial attribute transfer task, we propose a novel semantic-level facial attribute transfer method driven by text prompt, named as semantic directional decomposition network (SDD-Net). The SDD-Net extracts and transfers the specific attribute without redundant information through attribute-manipulated semantic directional decomposition. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are summarized as follows: ",
+        "bbox": [
+            176,
+            382,
+            472,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose a novel method namely directional latent mapping network for facial attribute editing, which utilizes the semantic direction consistency regularization to ensure attribute disentanglement. • To further take advantage of semantic direction constrain, we propose a text-driven semantic directional decomposition network (SDD-Net) for semantic-level attribute transfer, by transferring the knowledge from the reference image to the target image. • Extensive experiments on CelebA-HQ (Karras et al., 2017) dataset show that our method achieves significant improvements over the state-of-art approaches. ",
+        "bbox": [
+            217,
+            407,
+            825,
+            531
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            344,
+            568
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Latent Space Manipulation. Recent studies (Bau et al., 2020; Goetschalckx et al., 2019; Shen et al., 2020) have shown that numerous GAN models can encode rich crucial information in the intermediate latent space, such as $\\mathcal { W }$ , $\\mathcal { W } +$ (Abdal et al., 2019), or StyleSpace $s$ (Wu et al., 2021). By learning to modify the intermediate latent code, generative models can transfer attributes from one face to another face (Xiao et al., 2018; Choi et al., 2020). To find a latent code that allows for meaningful manipulation, some methods try to learn an effective encoder network, which inverts a real image into latent space: encoder4editing (e4e) (Tov et al., 2021) method presents an encoder that is specifically designed for balancing distortion-editability tradeoff and a distortion-perception tradeoff within the StyleGAN latent space; Stylespace (Wu et al., 2021) proposes a space of channelwise style parameters that disentangle attributes by controlling attribute-related style channels; The pixel2style2pixel (pSp) (Richardson et al., 2021) method utilizes a novel encoder architecture that inverts a real image into $\\mathcal { W } +$ space without optimization. Other methods mainly focus on finding such latent code modification approach as used to traverse latent space, result in the desired manipulation: AttGAN (He et al., 2019) applies attribute classification constraint to model the relation between the attributes and the latent representation; InterfaceGAN (Shen et al., 2020) decouples some entangled semantic features with subspace projection; GANspace (Hark ¨ onen et al., 2020) leverages ¨ principal component analysis to identify mainly direction in latent space; L2M-GAN (Yang et al., 2021a) imposes an orthogonality constraint to ensure disentanglement in latent space; StyleCLIP (Patashnik et al., 2021) leverages CLIP models to guide the attributes manipulation by latent semantic matching. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Different from the methods mentioned above, our method aligns the guidance direction, which is derived directly from text prompt, with the change direction of semantic features extracted by CLIP to guide the manipulation in the latent space. By constraining the consistency of these directions, our method can achieve disentangled attribute editing. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/0a855f9fd91735343743771b0cbbcd356d2018299f616cd16110b5d15d287c9f.jpg",
+        "image_caption": [
+            "Figure 1: Overview of our idea for directional latent mapping network. By enforcing the change direction of semantic feature to align with desired direction in CLIP-space, our method can achieve impressive disentangled image manipulation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            290,
+            103,
+            707,
+            270
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Semantic-level Attribute Transfer. Semantic-level attribute transfer is a more challenging facial attribute editing task. Recent studies have attempted more detailed approaches for facial attribute transfer: StarGAN (Choi et al., 2018) applies cycle consistency to preserve identity, and uses classification loss to transfer between different domains. In addition, StarGANv2 (Choi et al., 2020) also could synthesize reference-guide images leveraging multiple domain translation. Some works are specialized for specific attributes: ExprGAN (Ding et al., 2018) proposes a model to learn the disentangled identity and expression representations explicitly for facial expression transfer. Besides, ERGAN (Hu et al., 2020) proposes a dual learning scheme to simultaneously learn two inverse manipulations for attribute transfer. ",
+        "bbox": [
+            174,
+            357,
+            825,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Different from these works, our proposed method focuses not only on one attribute, but also on various global or local attributes. Given an explicit text prompt, our method can automatically extract the specific attribute from the reference, and transfer the knowledge to the target image. ",
+        "bbox": [
+            174,
+            489,
+            823,
+            531
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            339,
+            571
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the following section, we first provide the preliminaries and problem formulation. Then, we introduce our text-driven directional latent mapping network for disentangled facial attribute editing. Finally, we describe the text-driven semantic directional decomposition network (SDD-Net) for semantic-aware facial attribute transfer. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            646
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            669,
+            326,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "StyleGAN. The StyleGAN (Karras et al., 2019; 2020) generator consists of two main components: mapping network and synthesis network. The former translates latent code $z$ to latent code $w$ , which is in semantic-rich latent space $\\mathcal { W }$ , and the latter utilizes latent code $w$ to synthesize final images through different layers. Due to the rich information inside, the latent code $w$ can control the multigranularity semantic features of the synthetic image, which is utilized for effective facial attribute transfer in semantic-level. In this paper, we leverage the pre-trained synthesis network as our image generator. ",
+        "bbox": [
+            173,
+            695,
+            825,
+            794
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "StyleCLIP. The StyleCLIP (Patashnik et al., 2021) method first combines StyleGAN and CLIP as a strong tool for text-driven image editing. The key idea of StyleCLIP is to leverage the CLIP as latent manipulation guidance. By mapping multi-modal inputs to the CLIP-space, StyleCLIP could ensure that the synthetic image matches with the text prompt in semantic-level. The objective is given by: ",
+        "bbox": [
+            173,
+            799,
+            825,
+            857
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/69a233d8e91a3dd215da362e1e5bd4716b3123fadd6f7d836f115bb3d7176c4f.jpg",
+        "text": "$$\n\\mathcal { L } _ { s t y l e c l i p } = D _ { \\mathrm { C L I P } } ( G ( w ) , t e x t ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            867,
+            609,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $D _ { \\mathrm { C L I P } }$ is the cosine distance metric in CLIP-space, and $G$ is the pre-trained StyleGAN generator. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/9ab91a6a5e91c830f4013b388d228e7380eb6299535eaee7b90d708604bbb256.jpg",
+        "image_caption": [
+            "Figure 2: The architecture of our directional latent mapping network. Given the text prompt, we manipulate the latent code inverted by the facial images. Then we use $g$ group channel-wise mapping networks to manipulate the different parts of latent code $w$ respectively. Multiple loss functions are used to constrain the synthetic image to fulfil the requirements. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            104,
+            816,
+            291
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 PROBLEM FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            387,
+            392,
+            401
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our method leverages two latent space: $\\mathcal { W } +$ space and CLIP-space, to transfer semantic-level facial attributes. For better expression, let $\\mathcal { X }$ and $\\mathcal { V }$ denote the set of images and semantic features in CLIP-space, respectively. The image $x \\in \\mathcal { X }$ is inverted into corresponding latent code $w \\in \\mathcal { W } +$ . $t$ denotes the input text prompt, with corresponding semantic feature $y _ { t }$ . Meanwhile, the parameters of pre-trained StyleGANv2 generator $G$ are frozen during training. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            483
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the text prompt $t$ , the goal of facial attribute transfer model is to train a latent mapping network, which translates $w \\backslash y$ to $\\hat { w } \\textcircled { y }$ , and synthesizes the edited image $\\hat { x }$ that meets the specific requirements. Our basic editing model can be formally defined as $\\hat { x } = \\mathbf { \\bar { \\cal G } } ( M ( x , t ) )$ , where $M$ is the manipulation network. Hence given the reference image $x _ { r e f } \\in \\mathcal { X }$ , our semantic-aware attribute transfer model can be formally defined as $\\hat { x } = G ( M ( x , x _ { r e f } , t ) )$ . ",
+        "bbox": [
+            174,
+            489,
+            825,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 DIRECTIONAL LATENT MAPPING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            577,
+            444,
+            590
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Only focusing on matching $\\hat { y }$ with $y _ { t }$ may cause irrelevant attribute changed. Therefore, we enforce the mapping network to focus on the change direction of semantic features in CLIP-space, and illustrate this idea in Figure 1. The details of the proposed directional latent mapping network is described as follows: ",
+        "bbox": [
+            174,
+            602,
+            825,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Architecture. It has been shown that the different layers of synthesis network, which correspends to different parts of the latent code, control different granularity of semantic feature. In order to better exploit this property, we design the directional latent mapping network, and depict it in Figure 2. To a great extent, the degree of attributes disentanglement depends on the disentanglement of latent features. Therefore, we split the layers into $g$ groups, instead three (coarse, medium, and fine), with $g$ fully connected mapping networks, one for each group. The divided part of the latent code can be denoted as $w = [ w _ { 1 } , w _ { 2 } , . . . , w _ { g } ]$ , so the mapping network is defined by: ",
+        "bbox": [
+            173,
+            665,
+            825,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/49c6a828e010a65035483d74ffcde1a47b6189a8bc56236546b6cdf166822ef9.jpg",
+        "text": "$$\nM ( w ) = [ M _ { 1 } ( w _ { 1 } ) , M _ { 2 } ( w _ { 2 } ) , . . . , M _ { g } ( w _ { g } ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            765,
+            637,
+            782
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $M _ { i }$ is the $i$ -th mapping network, and $[ \\cdot , \\cdot ]$ means concat operation. Then we use skipconnection operation to obtain the final manipulated latent code $\\hat { w } = w + \\alpha M ( w )$ , and feed it to the pre-trained StyleGANv2 generator $G$ to get the final manipulated facial image $\\hat { x } = G ( \\hat { w } )$ . ",
+        "bbox": [
+            174,
+            785,
+            825,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Training Objective. The edited desired attribute is determined by the textual prompt $t$ . Without paired training data, the mapping network could not correctly manipulate the latent code. In order to obtain extra powerful supervision, we use CLIP model to effectively extract semantic features (attributes) $y$ of the corresponding images and text: ",
+        "bbox": [
+            174,
+            833,
+            823,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d692d41f4d85fba6dd6347bdc6553942435c17270e95d9fab483361e38e3f855.jpg",
+        "text": "$$\n\\begin{array} { c } { { y _ { i } ; \\hat { y _ { i } } = E _ { I } ( x ; \\hat { x } ) , } } \\\\ { { y _ { t } = E _ { T } ( t ) , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            892,
+            558,
+            929
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/6319cd20319308bfa543afbc202eb39dd245bfa6a592ab33ebaa36a063af4ee0.jpg",
+        "image_caption": [
+            "Figure 3: The illustration of attribute transfer loss $\\mathcal { L } _ { \\mathrm { A T } }$ in our Semantic Directional Decomposition Network (SDD-Net). We embed both the text prompt and reference\\target face into CLIP-space. When the projected vector $\\vec { \\mathcal { V } _ { p } }$ has the same direction with desired direction, the same attribute (e.g., smile) is transferred to the target face. Reversely, the opposite attribute (e.g., black hair) will be transferred when the direction is inverse. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            320,
+            102,
+            674,
+            295
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $E$ denotes the pre-trained multi-modal feature extractor integrated in CLIP, $y _ { i }$ and $\\hat { y } _ { i }$ denotes the extracted semantic features of $x$ and $\\hat { x }$ , respectively. $y _ { t }$ is the desired semantic feature extracted from textual prompt $t$ . ",
+        "bbox": [
+            174,
+            410,
+            825,
+            453
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the latent CLIP-space, simply optimizing the matching degree between $\\hat { y } _ { i }$ and $y _ { t }$ may cause irrelevant attribute to be changed. Therefore, rather than optimizing the matching degree to the utmost extent, we enforce the change direction between $y$ and $\\hat { y } _ { i }$ to align with the $y _ { t }$ , and propose the semantic direction consistency (SDC) loss. The SDC loss is given by: ",
+        "bbox": [
+            174,
+            459,
+            825,
+            516
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f59c5b0bec3f30a57dcb81418bab713dd45fe09b294dd777f151994b1f371180.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\vec { I } = \\hat { y _ { i } } - y _ { i } , } } \\\\ { { \\vec { T } = y _ { t } , } } \\\\ { { \\vec { \\mathcal { L } } _ { \\mathrm { S D C } } = 1 - S ( \\vec { I } , \\vec { T } ) , } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            521,
+            573,
+            587
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $S ( \\cdot , \\cdot )$ is the similarity measurement. In this paper, we use the effective cosine similarity as the measurement. ",
+        "bbox": [
+            171,
+            592,
+            825,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The above objective can guide the mapping network to manipulate the latent code along the direction of textual prompt. In order to preserve the irrelevant parts, we use the following identity loss: ",
+        "bbox": [
+            171,
+            627,
+            823,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61cc6a1853b9263316c0aaef5278d94a5ae258b28b820e46d89df03d26dd8671.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { I D } } = 1 - \\left. R ( G ( w ) ) , R ( G ( \\hat { w } ) ) \\right. ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            662,
+            614,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $R$ is a pre-trained ArcFace (Deng et al., 2019) network for face recognition, and $\\langle \\cdot , \\cdot \\rangle$ computes the cosine similarity between its two arguments. Meanwhile, we use $L _ { 2 }$ distance in $\\mathcal { W } +$ space to control the degree of manipulation. Then, the whole training objective for directional latent mapping network is denoted as: ",
+        "bbox": [
+            174,
+            686,
+            825,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0573425177fb302ecf79de2e26095c35a9c9ca1301c074c28b52a763aca7325e.jpg",
+        "text": "$$\n\\underset { w \\in \\mathcal { W } + } { \\arg \\operatorname* { m i n } } \\lambda _ { \\mathrm { S D C } } \\mathcal { L } _ { \\mathrm { S D C } } ( w , t ) + \\lambda _ { L 2 } | | M ( w ) | | _ { 2 } + \\lambda _ { \\mathrm { I D } } \\mathcal { L } _ { \\mathrm { I D } } ( w ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            750,
+            694,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 SEMANTIC DIRECTIONAL DECOMPOSITION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            791,
+            516,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the above method, we found that a semantic attribute translation can be represented as a directional vector in CLIP-space. Based on this, we leverage the same architecture of directional mapping network, and propose a facial attribute transfer method via semantic-aware knowledge transfer, named as semantic directional decomposition network (SDD-Net). ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given the textual prompt $t$ , we want to transfer the attribute, extracted from the reference image $x _ { r e f }$ , to the target image $x _ { t a r }$ . The $y _ { r e f }$ and $y _ { t a r }$ are their corresponding semantic features respectively. And the semantic feature of textual prompt $t$ is $y _ { t }$ . ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a42c290dc0d3755ecd6b895c9e1dbab8d88f351e03476d25131bed5a4d947f7a.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative results for facial attribute editing on attribute “smile”. The left column are the target images sampled from CelebA-HQ dataset. The other column from left to right are the editing results of L2M-GAN (Yang et al., 2021a), StyleCLIP\\* (Patashnik et al., 2021), and our directional latent mapping network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            305,
+            106,
+            687,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Due to the above direction-based manipulation, we can treat the facial attribute transfer problem as the attribute semantic feature projection problem. In the CLIP-space, a facial image can be treated as the composition of different semantic features. Therefore, we assume that different facial images can be converted to each other in semantic-level. In other words, one semantic feature can be translated to another semantic feature. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            545
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Under such an assumption, we first define the RT (reference-target) vector as: $\\mathcal { V } _ { R T } ^ {  } = y _ { r e f } - y _ { t a r }$ , which is the variance of two semantic features, and also is the direction of translation. We set the $y _ { t }$ as the projection direction. In order to extract knowledge from the reference, we project RT vector $\\vec { \\nu _ { R T } }$ onto desired direction $\\vec { \\mathcal { V } } _ { t } = \\boldsymbol { y } _ { t }$ : ",
+        "bbox": [
+            173,
+            551,
+            825,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e912408a07b24d5148334f231af090ff538834d0c1cb68d630df53996cf1eced.jpg",
+        "text": "$$\n\\vec { \\mathcal { V } _ { p } } = \\mathcal { V } _ { R T } ^ {  } \\cdot ( \\frac { \\vec { \\mathcal { V } _ { t } } } { | \\mathcal { V } _ { t } | } ) ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            631,
+            576,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\vec { \\mathcal { V } _ { p } }$ is the projected vector. Then we add it to the target semantic feature $y _ { t a r }$ to get the final goal: ",
+        "bbox": [
+            174,
+            684,
+            825,
+            714
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b1953999dce094da238953578e9aaac69ac01fc5c4bbd6cbf37a6a90510864b7.jpg",
+        "text": "$$\ny _ { g o a l } = y _ { t a r } + \\beta \\vec { \\mathcal { V } _ { p } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            715,
+            566,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\beta$ is the hyperparameter. ",
+        "bbox": [
+            174,
+            742,
+            379,
+            757
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training Objective. We use same architecture of directional latent mapping network to obtain the manipulated image $\\hat { x } = G ( M ( \\hat { w } ) )$ , then match the semantic feature $\\hat { y } = E _ { I } ( \\hat { x } )$ with $y _ { g o a l }$ in CLIP-space. As illustrated in Figure 3, the attribute transfer loss $\\mathcal { L } _ { \\mathrm { A T } }$ is given by: ",
+        "bbox": [
+            174,
+            763,
+            825,
+            806
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cba301187b893805ac784915bab18c511d3f9fae6ee99a377ff5e5792104f7db.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { A T } } = \\mathrm { M S E } ( \\hat { y } , y _ { g o a l } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            815,
+            576,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { M S E } ( \\cdot , \\cdot )$ is the mean squared error. ",
+        "bbox": [
+            176,
+            842,
+            455,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Meanwhile, we use the same $L 2$ loss and identity loss to preserve the irrelevant parts. The whole training objective of SDD-Net is: ",
+        "bbox": [
+            171,
+            863,
+            825,
+            892
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ddd12d3cb52042f904e9e898825e776d66ce2a50abdd6fadab0ca762686b1ff4.jpg",
+        "text": "$$\n\\operatorname* { a r g m i n } _ { w \\in \\mathcal { W } + } \\lambda _ { \\mathrm { A T } } \\mathcal { L } _ { \\mathrm { A T } } + \\lambda _ { \\mathrm { L 2 } } \\mathcal { L } _ { \\mathrm { 2 } } + \\lambda _ { \\mathrm { I D } } \\mathcal { L } _ { \\mathrm { I D } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            901,
+            629,
+            928
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/32527924cb4a64c62e9b2fa1e9563a20ec8e5225f4869fab2b07231e7afb59eb.jpg",
+        "image_caption": [
+            "Figure 5: The qualitative results of our SDD-Net on single attribute transfer. Reference images in the left column. Target images in the first row of each parts, the rest is our manipulated images. Given the text prompt, our SDD-Net transfer the specific attribute (“smile”) to the target images (top part) when the reference have the specific attribute. By contrast, the reverse attribute (“unsmiling”) will be transferred (bottom part) when the specific attribute is not contained in the reference. Notice that, we only input one text prompt. So the SDD-Net could determine the forward or reverse transferring direction, according to the reference. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            104,
+            803,
+            397
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            539,
+            326,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first introduce the involved dataset and the implementation details. Then we will present the comparison results with several state-of-the-art facial attribute editing and facial attribute transfer methods to prove the effectiveness of our proposed method. Finally, the ablation studies will be presented to prove the effectiveness of our method. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            626
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            645,
+            279,
+            659
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to achieve text-driven facial attribute editing and transfer, we choose the widely-used CelebA-HQ (Karras et al., 2017) dataset, which consists of 30,000 high quality facial images picked from the original CelebA (Liu et al., 2015) dataset. The size of each high quality image is $1 0 2 4 \\times 1 0 2 4$ . In the original dataset, each image has 40 attributes annotations inherited from the original CelebA. However in this work, we remove these annotations, and leverage CLIP model as powerful supervision. We also use the standard training, validation and test splits inherited from CelebA dataset. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            768
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            786,
+            405,
+            800
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this subsection we provide the implementation details of our proposed networks. All images taken from the CelebA-HQ are inverted by e4e (Tov et al., 2021). We set the batch size and the number of total iterations to 5 and 50k respectively, during training. Our image editing is performed on StyleGANv2 pre-trained on FFHQ (Karras et al., 2019) dataset. We keep the StyleGANv2 generator fixed during training. The CLIP model is pre-trained on 400 million image-text pairs. We use the Vision Transformer (ViT) (Dosovitskiy et al., 2020) and a normal Transformer (Vaswani et al., 2017), which are integrated in CLIP model, as our image encoder and text encoder, respectively. Our directional latent mapping module is initialized using the pre-trained StyleGANv2, and trained using Adam with the learning rate 5e-3. We set $g = 9$ , $\\alpha = 0 . 1$ , and $\\beta = 1 3 0$ . For facial attribute editing, the hyperparameters are empirically set as $\\lambda _ { S D C } = 1$ , $\\lambda _ { L 2 } = 0 . 4$ , and $\\lambda _ { \\mathrm { I D } } = 0 . 0 2$ . For facial attribute transfer, the hyperparameters are empirically set as $\\lambda _ { \\mathrm { A T } } = 1$ , $\\lambda _ { L 2 } = 0 . 2$ , and $\\lambda _ { \\mathrm { I D } } =$ 0.02. Our methods are trained on PyTorch with a single TITAN RTX GPU. We optimize training objective through gradient descent, by back-propagating the gradient through the pre-trained and fixed StyleGAN generator $G$ and CLIP multi-modal encoder $E$ . ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/881485244855762ebbec0b98b0a6e810c0a3080469b5802969e477e744d83c5a.jpg",
+        "image_caption": [
+            "Figure 6: Experiments on reference-guided image synthesis on CelebA-HQ. Reference and target images both in the first row. The second and third raw are the synthetic results of StarGANv2 (Choi et al., 2020) and our SDD-Net respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            103,
+            820,
+            287
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            378,
+            825,
+            463
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 BASELINE METHODS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            361,
+            501
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Facial Attribute Editing Methods. We first compare our directional latent mapping network with the state-of-the-art facial attribute editing methods (i.e., L2M-GAN (Yang et al., 2021a), and StyleCLIP (Patashnik et al., 2021)) for the specific attribute: “smile”. Due to the requirements of highlevel semantic-aware knowledge, the smile attribute has become one of the most challenging global attributes. For L2M-GAN, we set the attribute domains as two (“smile” and “sad”), leveraging the domain label to guide the manipulation. For StyleCLIP, we use the latent mapper network as the baseline model, which is marked as StyleCLIP\\*. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            613
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Facial Attribute Transfer Methods. The StarGANv2 (Choi et al., 2020) learns to transform a source image reflecting the style of a given reference image. We compare our SDD-Net with StarGANv2 method on reference-guided image synthesis, which is a challenging facial attribute transfer task. Reference-guided image synthesis requires that various high-level attributes in the reference images, such as hairstyle, makeup, beard and expression, should be transferrd to the target images, while the irrelevant information such as pose and identity should be preserved. For fair comparison, we resize the images to $2 5 6 \\times 2 5 6$ in reference-guided image synthesis. ",
+        "bbox": [
+            174,
+            619,
+            825,
+            718
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 RESULTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            742,
+            387,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Facial Attribute Editing. The qualitative results are shown in Figure 4. After careful comparison, we have following observations: (1) The L2M-GAN performs well at disentangling attributes during editing. However, due to the strong constrain of orthogonal loss, the manipulated attribute is not obvious. (2) Although the StyleCLIP\\* method can make the best use of semantic knowledge of CLIP-space, the irrelevant attributes are changed in facial attribute editing without correct guidance direction. (3) Our directional latent mapping network manipulates the attribute correctly and naturally, which demonstrates that the proposed semantic directional consistency (SDC) loss could enforce the editing model to change specific attributes while preserving irrelevant parts. It also proves that there exists latent directions corresponding to different semantic properties in latent space. By manipulating latent code along such direction or its opposite direction, we can add or remove attributes. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Facial Attribute Transfer. Inspired by the above direction-based latent space manipulation for facial attribute transfer, we leverage this peculiarity for facial attribute transfer task. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We first execute our SDD-Net on the “smile” attribute for single attribute transfer, and input the corresponding text prompt to the model. The qualitative results are shown in Figure 5. We observe that when reference has the consistent attribute appointed by the prompt, the SDD-Net could correctly transfer the specific attribute to the target face with irrelevant information preserved, as shown in the top part. On the contrary, when the reference has the opposite attribute, our SDD-Net also could transfer opposite attribute to the target without extra guidance. By fully leveraging the knowledge of CLIP-space, our SDD-Net could find the semantic-aware latent direction in the latent space. The experiments show the excellent performance of our SDD-Net. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the reference-guide image synthesis, we set the projected vector $\\vec { \\mathcal { V } _ { p } }$ is equal to the RT vector $\\vec { \\nu _ { R T } }$ . Figure 6 provides qualitative comparison of the results. We observe that StarGANv2 mothed synthesizes images with a same style code. However, the results show that StarGANv2 model manipulates images in a limited space. As a result, the attributes of the synthetic faces tend to be exactly alike. In addition, the expression attribute such as “smile” is ignored during transferring. Compared to StarGANv2, our SDD-Net transfers the multiple meaningful attributes to each of the target faces in semantic-level. Meanwhile, our method manipulates the image along the latent direction leveraging the knowledge of CLIP in latent space, which allows our method to synthesize realistic facial images, rather than simple style transfer. ",
+        "bbox": [
+            174,
+            258,
+            825,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            409,
+            339,
+            422
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We conduct a qualitative ablation study, as shown in Figure 7, and show the significance of identity loss. We observe that, when hyperparameter $\\lambda _ { \\mathrm { I D } } = 0 . 1$ , the ID loss hinders the attribute transfer. Then we experiment with $\\lambda _ { \\mathrm { I D } } ~ = ~ 0$ , the attribute could be correctly transferred, but the identity information is changed. To trade-off, we set the $\\lambda _ { \\mathrm { I D } } = 0 . 0 2$ . ",
+        "bbox": [
+            174,
+            436,
+            825,
+            492
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a6296e98bdcc63d20c6418746537725052a3e376b135b68d3f5699b724454f5e.jpg",
+        "image_caption": [
+            "Figure 7: The ablation study of identity loss. Under each column we specify $( \\lambda _ { \\mathrm { I D } } )$ ) identity loss. Obviously the ID loss is significant for facial attribute transfer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            294,
+            512,
+            705,
+            712
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            328,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we first propose directional latent mapping network for text-driven facial attribute editing. By leveraging semantic direction consistency (SDC) loss, the directional latent mapping network could correctly edit relevant attribute while preserving irrelevant attributes. And on this basis, we propose semantic directional decomposition network (SDD-Net) for text-driven facial attribute transfer, which correctly transfers the semantic-aware attributes of reference image to the target image. Experiments show that our method achieves impressive performance on CelebA-HQ dataset. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            285,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan: How to embed images into the stylegan latent space? In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 4432–4441, 2019. ",
+        "bbox": [
+            174,
+            126,
+            821,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Bau, Hendrik Strobelt, William Peebles, Jonas Wulff, Bolei Zhou, Jun-Yan Zhu, and Antonio Torralba. Semantic photo manipulation with a generative image prior. arXiv preprint arXiv:2005.07727, 2020. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yunjey Choi, Minje Choi, Munyoung Kim, Jung-Woo Ha, Sunghun Kim, and Jaegul Choo. Stargan: Unified generative adversarial networks for multi-domain image-to-image translation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 8789–8797, 2018. ",
+        "bbox": [
+            174,
+            232,
+            826,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yunjey Choi, Youngjung Uh, Jaejun Yoo, and Jung-Woo Ha. Stargan v2: Diverse image synthesis for multiple domains. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8188–8197, 2020. ",
+        "bbox": [
+            174,
+            299,
+            826,
+            342
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiankang Deng, Jia Guo, Niannan Xue, and Stefanos Zafeiriou. Arcface: Additive angular margin loss for deep face recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4690–4699, 2019. ",
+        "bbox": [
+            173,
+            352,
+            823,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hui Ding, Kumar Sricharan, and Rama Chellappa. Exprgan: Facial expression editing with controllable expression intensity. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018. ",
+        "bbox": [
+            174,
+            405,
+            823,
+            448
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Garoe Dorta, Sara Vicente, Neill DF Campbell, and Ivor JA Simpson. The gan that warped: Semantic attribute editing with unpaired data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 5356–5365, 2020. ",
+        "bbox": [
+            173,
+            458,
+            825,
+            502
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lore Goetschalckx, Alex Andonian, Aude Oliva, and Phillip Isola. Ganalyze: Toward visual definitions of cognitive image properties. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 5744–5753, 2019. ",
+        "bbox": [
+            173,
+            578,
+            823,
+            622
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. Advances in neural information processing systems, 27, 2014. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            675
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Erik Hark ¨ onen, Aaron Hertzmann, Jaakko Lehtinen, and Sylvain Paris. Ganspace: Discovering ¨ interpretable gan controls. arXiv preprint arXiv:2004.02546, 2020. ",
+        "bbox": [
+            173,
+            685,
+            823,
+            714
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhenliang He, Wangmeng Zuo, Meina Kan, Shiguang Shan, and Xilin Chen. Attgan: Facial attribute editing by only changing what you want. IEEE transactions on image processing, 28(11):5464– 5478, 2019. ",
+        "bbox": [
+            173,
+            723,
+            826,
+            766
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhenliang He, Meina Kan, Jichao Zhang, and Shiguang Shan. Pa-gan: Progressive attention generative adversarial network for facial attribute editing. arXiv preprint arXiv:2007.05892, 2020. ",
+        "bbox": [
+            169,
+            776,
+            823,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bingwen Hu, Zhedong Zheng, Ping Liu, Wankou Yang, and Mingwu Ren. Unsupervised eyeglasses removal in the wild. IEEE Transactions on Cybernetics, 2020. ",
+        "bbox": [
+            171,
+            816,
+            823,
+            845
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Jahanian, Lucy Chai, and Phillip Isola. On the” steerability” of generative adversarial networks. arXiv preprint arXiv:1907.07171, 2019. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. Progressive growing of gans for improved quality, stability, and variation. arXiv preprint arXiv:1710.10196, 2017. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4401–4410, 2019. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Samuli Laine, Miika Aittala, Janne Hellsten, Jaakko Lehtinen, and Timo Aila. Analyzing and improving the image quality of stylegan. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 8110–8119, 2020. ",
+        "bbox": [
+            176,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeong-gi Kwak, David K Han, and Hanseok Ko. Cafe-gan: Arbitrary face attribute editing with complementary attention feature. In Computer Vision–ECCV 2020: 16th European Conference, Glasgow, UK, August 23–28, 2020, Proceedings, Part XIV 16, pp. 524–540. Springer, 2020. ",
+        "bbox": [
+            176,
+            205,
+            821,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro ´ Acosta, Andrew Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, et al. Photo-realistic single image super-resolution using a generative adversarial network. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4681–4690, 2017. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chen-Hsuan Lin, Ersin Yumer, Oliver Wang, Eli Shechtman, and Simon Lucey. St-gan: Spatial transformer generative adversarial networks for image compositing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9455–9464, 2018. ",
+        "bbox": [
+            174,
+            321,
+            821,
+            364
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ming Liu, Yukang Ding, Min Xia, Xiao Liu, Errui Ding, Wangmeng Zuo, and Shilei Wen. Stgan: A unified selective transfer network for arbitrary image attribute editing. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3673–3682, 2019. ",
+        "bbox": [
+            174,
+            372,
+            823,
+            416
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of the IEEE international conference on computer vision, pp. 3730–3738, 2015. ",
+        "bbox": [
+            173,
+            424,
+            821,
+            454
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yotam Nitzan, Rinon Gal, Ofir Brenner, and Daniel Cohen-Or. Large: Latent-based regression through gan semantics. arXiv preprint arXiv:2107.11186, 2021. ",
+        "bbox": [
+            174,
+            462,
+            821,
+            491
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Or Patashnik, Zongze Wu, Eli Shechtman, Daniel Cohen-Or, and Dani Lischinski. Styleclip: Textdriven manipulation of stylegan imagery. arXiv preprint arXiv:2103.17249, 2021. ",
+        "bbox": [
+            173,
+            498,
+            820,
+            529
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. arXiv preprint arXiv:2103.00020, 2021. ",
+        "bbox": [
+            174,
+            536,
+            823,
+            579
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Elad Richardson, Yuval Alaluf, Or Patashnik, Yotam Nitzan, Yaniv Azar, Stav Shapiro, and Daniel Cohen-Or. Encoding in style: a stylegan encoder for image-to-image translation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2287–2296, 2021. ",
+        "bbox": [
+            176,
+            587,
+            825,
+            631
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yujun Shen, Jinjin Gu, Xiaoou Tang, and Bolei Zhou. Interpreting the latent space of gans for semantic face editing. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 9243–9252, 2020. ",
+        "bbox": [
+            176,
+            638,
+            823,
+            681
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Omer Tov, Yuval Alaluf, Yotam Nitzan, Or Patashnik, and Daniel Cohen-Or. Designing an encoder for stylegan image manipulation. ACM Transactions on Graphics (TOG), 40(4):1–14, 2021. ",
+        "bbox": [
+            168,
+            689,
+            825,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zongze Wu, Dani Lischinski, and Eli Shechtman. Stylespace analysis: Disentangled controls for stylegan image generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 12863–12872, 2021. ",
+        "bbox": [
+            176,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Taihong Xiao, Jiapeng Hong, and Jinwen Ma. Elegant: Exchanging latent encodings with gan for transferring multiple face attributes. In Proceedings of the European conference on computer vision (ECCV), pp. 168–184, 2018. ",
+        "bbox": [
+            174,
+            830,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yinghao Xu, Yujun Shen, Jiapeng Zhu, Ceyuan Yang, and Bolei Zhou. Generative hierarchical features from synthesizing images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4432–4442, 2021. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guoxing Yang, Nanyi Fei, Mingyu Ding, Guangzhen Liu, Zhiwu Lu, and Tao Xiang. L2m-gan: Learning to manipulate latent space semantics for facial attribute editing. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2951–2960, 2021a. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tao Yang, Peiran Ren, Xuansong Xie, and Lei Zhang. Gan prior embedded network for blind face restoration in the wild. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 672–681, 2021b. ",
+        "bbox": [
+            176,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Raymond A Yeh, Chen Chen, Teck Yian Lim, Alexander G Schwing, Mark Hasegawa-Johnson, and Minh N Do. Semantic image inpainting with deep generative models. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 5485–5493, 2017. ",
+        "bbox": [
+            174,
+            207,
+            823,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Weidong Yin, Ziwei Liu, and Chen Change Loy. Instance-level facial attributes transfer with geometry-aware flow. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 9111–9118, 2019. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            300
+        ],
+        "page_idx": 11
+    }
+]

parse/dev/PUIqjT4rzq7/PUIqjT4rzq7.md

@@ -0,0 +1,410 @@
+# TRAINING-FREE STRUCTURED DIFFUSION GUIDANCE FOR COMPOSITIONAL TEXT-TO-IMAGE SYNTHESIS
+
+Weixi Feng1, Xuehai $\mathbf { H e } ^ { 2 }$ , Tsu-jui $\mathbf { F u } ^ { 1 }$ , Varun Jampani3, Arjun Akula3, Pradyumna Narayana3, Sugato Basu3, Xin Eric Wang2, William Yang Wang1 1University of California, Santa Barbara, 2University of California, Santa Cruz, 3Google
+
+# ABSTRACT
+
+Large-scale diffusion models have achieved state-of-the-art results on text-to-image synthesis (T2I) tasks. Despite their ability to generate high-quality yet creative images, we observe that attribution-binding and compositional capabilities are still considered major challenging issues, especially when involving multiple objects. Attribute-binding requires the model to associate objects with the correct attribute descriptions, and compositional skills require the model to combine and generate multiple concepts into a single image. In this work, we improve these two aspects of T2I models to achieve more accurate image compositions. To do this, we incorporate linguistic structures with the diffusion guidance process based on the controllable properties of manipulating cross-attention layers in diffusion-based T2I models. We observe that keys and values in cross-attention layers have strong semantic meanings associated with object layouts and content. Therefore, by manipulating the cross-attention representations based on linguistic insights, we can better preserve the compositional semantics in the generated image. Built upon Stable Diffusion, a SOTA T2I model, our structured cross-attention design is efficient that requires no additional training samples. We achieve better compositional skills in qualitative and quantitative results, leading to a significant $5- 8 \%$ advantage in head-to-head user comparison studies. Lastly, we conduct an in-depth analysis to reveal potential causes of incorrect image compositions and justify the properties of cross-attention layers in the generation process.
+
+# 1 INTRODUCTION
+
+Text-to-Image Synthesis (T2I) is to generate natural and faithful images given a text prompt as input. Recently, there has been a significant advancement in the quality of generated images by extremely large-scale vision-language models, such as DALL-E 2 (Ramesh et al., 2022), Imagen (Saharia et al., 2022), and Parti (Yu et al., 2022). In particular, Stable Diffusion (Rombach et al., 2022) is the state-of-the-art open-source implementation showing superior evaluation metric gains after training over billions of text-image pairs.
+
+In addition to generating high-fidelity images, the ability to compose multiple objects into a coherent scene is also essential. Given a text prompt from the user end, T2I models need to generate an image that contains all necessary visual concepts as mentioned in the text. Achieving such ability requires the model to understand both the full prompt and individual linguistic concepts from the prompt. As a result, the model should be able to combine multiple concepts and generate novel objects that have never been included in the training data. In this work, we mainly focus on improving the compositionality of the generation process, as it is essential to achieve controllable and generalized text-to-image synthesis with multiple objects in a complex scene.
+
+Attribute binding is a critical compositionality challenge (Ramesh et al., 2022; Saharia et al., 2022) to existing large-scale diffusion-based models. Despite the improvements in generating multiple objects in the same scene, existing models still fail when given a prompt such as “a brown bench in front of a white building” (see Fig. 1). The output images contains “a white bench” and “a brown building” instead, potentially due to strong training set bias or imprecise language understanding. From a practical perspective, explaining and solving such a two-object binding challenge is a primary step to understanding more complex prompts with multiple objects. Therefore, how to bind the attributes to the correct objects is a fundamental problem for a more complicated and reliable compositional generation. While previous work has addressed compositional T2I (Park et al., 2021), our work tackles open-domain foreground objects with counterfactual attributes, such as color and materials.
+
+![](images/b61a2adf2a0c4ffb5419a27d01d3d821224796a6f7589f156e3de323e338125e.jpg)  
+Figure 1: Three challenging phenomena in the compositional generation. Attribute leakage: The attribute of one object is (partially) observable in another object. Interchanged attributes: the attributes of two or more objects are interchanged. Missing objects: one or more objects are missing. With slight abuse of attribute binding definitions, we aim to address all three problems in this work.
+
+Even though state-of-the-art (SOTA) T2I models are trained on large-scale text-image datasets, they can still suffer from inaccurate results for simple prompts similar to the example above. Hence, we are motivated to seek an alternative, data-efficient method to improve the compositionality. We observe that the attribute-object relation pairs can be obtained as text spans for free from the parsing tree of the sentence. Therefore, we propose to combine the structured representations of prompts, such as a constituency tree or a scene graph, with the diffusion guidance process. Text spans only depict limited regions of the whole image. Conventionally, we need spatial information such as coordinates (Yang et al., 2022) as input to map their semantics into corresponding images. However, coordinate inputs cannot be interpreted by T2I models. Instead, we make use of the observations that attention maps provide free token-region associations in trained T2I models (Hertz et al., 2022). By modifying the key-value pairs in cross-attention layers, we manage to map the encoding of each text span into attended regions in 2D image space.
+
+In this work, we discover similar observations in Stable Diffusion (Rombach et al., 2022) and utilize the property to build structured cross-attention guidance. Specifically, we use language parsers to obtain hierarchical structures from the prompts. We extract text spans across all levels, including visual concepts or entities, and encode them separately to disentangle the attribute-object pairs from each other. Compared to using a single sequence of text embedding for guidance, we improve the compositionality by multiple sequences where each emphasizes an entity or a union of entities from multiple hierarchies in the structured language representations. We refer to our method as Structured Diffusion Guidance (StructureDiffusion). Our contributions can be summarized as three-fold:
+
+• We propose an intuitive and effective method to improve compositional text-to-image synthesis by utilizing structured representations of language inputs. Our method is efficient and training-free that requires no additional training samples.   
+• Experimental results show that our method achieves more accurate attribute binding and compositionality in the generated images. We also propose a benchmark named Attribute Binding Contrast set (ABC-6K) to measure the compositional skills of T2I models.   
+• We conduct extensive experiments and analysis to identify the causes of incorrect attribute binding, which points out future directions in improving the faithfulness and compositionality of text-to-image synthesis.
+
+![](images/09bca81db2a15f234e6b30d656ac74ab6f9b1cbc101365fd59e52c1916f786df.jpg)  
+Figure 2: An illustration of cross-attention operations and the token-region associations from attention maps. We omit some tokens for simplicity.
+
+# 2 DIFFUSION MODELS & STRUCTURED GUIDANCE
+
+In this section, we propose a simple yet effective approach incorporating structured language representations into the cross-attention layers. We briefly introduce the Stable Diffusion model and its critical components in Sec. 2.1. Then, we present our method in detail in Sec. 2.2.
+
+# 2.1 BACKGROUND
+
+Stable Diffusion We implement our approach and experiments on the state-of-the-art T2I model, Stable Diffusion (Rombach et al., 2022). It is a two-stage method that consists of an autoencoder and a diffusion model. The pre-trained autoencoder encodes images as lower-resolution latent maps for diffusion training. During inference, it decodes generated outputs from the diffusion model into images. The diffusion model generates lower-resolution latent maps based on a random Gaussian noise input $z ^ { T }$ . Given $z ^ { T }$ , it outputs a noise estimation $\epsilon$ at each step $t$ and subtracts it from $z ^ { t }$ . The final noise-free latent map prediction $z ^ { 0 }$ is fed into the autoencoder to generate images. Stable Diffusion adopts a modified UNet (Ronneberger et al., 2015) for noise estimation and a frozen CLIP text encoder (Radford et al., 2021) to encode text inputs as embedding sequences. The interactions between the image space and the textual embeddings are achieved through multiple cross-attention layers in both downsampling and upsampling blocks.
+
+CLIP Text Encoder Given an input prompt $\mathcal { P }$ , the CLIP encoder encodes it as a sequence of embeddings ${ \mathcal { W } } _ { \mathrm { p } } = \mathbf { C } \mathbf { L I P } _ { \mathrm { t e x t } } ( \mathcal { P } )$ where $c _ { \mathrm { p } }$ is the embedding dimension and $l$ is the sequence length. Our key observation is that the contextualization of CLIP embeddings is a potential cause of incorrect attribute binding. Due to the causal attention masks, tokens in the later part of a sequence are blended with the token semantics before them. For example, When the user indicates some rare color for the second object (e.g. “a yellow apple and red bananas”), Stable Diffusion tends to generate “banana” in “yellow”, as the embeddings of “yellow” is attended by token “banana”.
+
+Cross Attention Layers The cross-attention layers take the embedding sequences from the CLIP text encoder and fuse them with latent feature maps to achieve classifier-free guidance. Denote a 2D feature map $\mathcal { X } ^ { t }$ , it is projected into queries by a linear layer $f _ { Q } ( \cdot )$ and reshaped as $Q ^ { t } \in R ^ { ( n , h \times w , d ) }$ where $n$ denotes the number of attention heads, $d$ is the feature dimension. Similarly ${ \mathcal W } _ { \mathfrak p }$ is projected as keys and values $K _ { \mathfrak { p } } , V _ { \mathfrak { p } } \in R ^ { ( n , l , d ) }$ by linear layers $f _ { K } ( \cdot ) , f _ { V } ( \cdot )$ . The attention maps refer to the product between queries and keys, denoted as a function $f _ { M } ( \cdot )$
+
+$$
+M ^ { t } = f _ { M } ( Q ^ { t } , K _ { p } ) = \mathrm { S o f t m a x } ( \frac { Q ^ { t } K _ { \mathrm { p } } ^ { T } } { \sqrt { d } } ) , M ^ { t } \in R ^ { ( n , h \times w , l ) } .
+$$
+
+![](images/a4f20aec4802f8a65ee210c0541bcc6905c7389daea131d1a009bc1e10573207.jpg)  
+Figure 3: An illustration of our cross-attention design with structured representations. We unflatten the query and attention maps and omit the feature dimension $d$ of all query, key, and value tensors for demonstration purposes. Note that noun phrases at multiple hierarchies are extracted and encoded through the frozen CLIP text encoder and projected to value vectors.
+
+Cross Attention Controls Hertz et al. (2022) observes that the spatial layouts depend on the cross attention maps in Imagen Saharia et al. (2022). These maps control the layout and structure of generated images, while the values contain rich semantics mapped into attended regions. Therefore, we assume that the image layout and content can be disentangled by controlling attention maps and values separately.
+
+# 2.2 STRUCTURED DIFFUSION GUIDANCE
+
+Given the challenging prompts in Fig. 1, the attribute-object pairs are available for free1 in many structured representations, such as a constituency tree or a scene graph. We seek an implicit way of combining language structures with the cross-attention layers. As is shown in Fig. 3, we can extract multiple noun phrases (NPs) and map their semantics into corresponding regions. Since $M _ { t }$ provides natural token-region associations (see Fig. 2), we can apply it to multiple values from different NPs to achieve region-wise semantic guidance.
+
+Specifically, given a parser $\xi ( \cdot )$ , we first extract a collection of concepts from all hierarchical levels as $\mathcal { C } = \{ c _ { 1 } , c _ { 2 } , \ldots , c _ { k } \}$ . For constituency parsing, we extract all NPs from the tree structure (see Fig.3 left). For the scene graphs, we extract objects and their relations with another object as text segments. We encode each NP separately:
+
+$$
+\mathbb { W } = [ \mathcal { W } _ { \mathrm { p } } , \mathcal { W } _ { 1 } , \mathcal { W } _ { 2 } , \ldots , \mathcal { W } _ { k } ] , \mathcal { W } _ { i } = \mathbf { C } \mathbf { L } \mathbf { I } \mathbf { P } _ { \mathrm { t e x t } } ( c _ { i } ) , i = 1 , \ldots k .
+$$
+
+The embedding sequence $\mathcal { W } _ { i }$ is realigned with $\mathcal { W } _ { p }$ as shown in the middle of Fig. 3. Embeddings between $\left. \mathbf { b o s } \right.$ and $\langle \mathrm { p a d } \rangle$ are inserted into $\mathcal { W } _ { p }$ to create a new sequence, denoted as $\overline { { \mathcal { W } } } _ { i }$ . We use $\overline { { \mathcal { W } } } _ { \mathrm { p } }$ to obtain $K _ { \mathfrak { p } }$ and $M ^ { t }$ as in Eq. 1, assuming that the full-prompt key is able to generate layouts without missing objects. We obtain a set of values from $\mathbb { W }$ and multiply each with ${ \bf { \bar { \boldsymbol { M } } } } ^ { t }$ to achieve a conjunction of $k$ NPs in $\mathcal { C }$ :
+
+$$
+\begin{array} { c } { \mathbb { V } = [ f _ { V } ( \mathcal { W } _ { \mathrm { p } } ) , f _ { V } ( \overline { { \mathcal { W } } } _ { 1 } ) , \ldots , f _ { V } ( \overline { { \mathcal { W } } } _ { k } ) ] = [ V _ { \mathrm { p } } , V _ { 1 } , \ldots , V _ { k } ] . } \\ { O ^ { t } = \displaystyle \frac { 1 } { ( k + 1 ) } \sum _ { i } ( M ^ { t } V _ { i } ) , i = \mathrm { p } , 1 , 2 , \ldots , k . } \end{array}
+$$
+
+Compared to using $f _ { V } ( \mathscr { W } _ { p } )$ only, Eq. 4 does not modify the image layout or composition since $M ^ { t }$ is still calculated from $Q ^ { t } , K _ { p }$ . Empirically, we justify the claim by a series of visualizations of $M _ { t }$
+
+# Algorithm 1 StructureDiffusion Guidance.
+
+# Require:
+
+Input: Prompt $\mathcal { P }$ , Parser $\xi$ , decoder $\psi$ , trained diffusion model $\phi$ .   
+Output: Generated image $x$ .   
+1: Retrieve concept set ${ \mathcal { C } } = [ c _ { 1 } , \ldots , c _ { k } ]$ by traversing $\xi ( \mathcal { P } )$ ;   
+2: $\mathcal { W } _ { \mathrm { p } }  \mathrm { C L I P } _ { \mathrm { t e x t } } ( \mathcal { P } ) .$ , ${ \mathcal { W } } _ { i } \gets \mathbf { C } \mathbf { L I P _ { \mathrm { t e x t } } } ( c _ { i } )$ ; $i = 1 , \ldots , k$   
+3: for $t = T , T - 1 , \dots , 1$ do   
+4: for each cross attention layer in $\phi$ do   
+5: Obtain previous layer’s output $\mathcal { X } ^ { t }$ .   
+6: $Q ^ { t } \gets \hat { f } _ { Q } ( \mathcal { X } ^ { t } ) , \ \dot { K _ { \mathrm { p } } } \gets \boldsymbol { f } _ { K } \mathsf { \bar { ( } } \mathcal { W _ { \mathrm { p } } ) } , \ V _ { i } \gets f _ { V } ( \overline { { \mathcal { W } } } _ { i } ) ;$ $\begin{array} { r } { i = { \tt p } , 1 , \ldots , k } \\ { \{ { \tt E q . ~ } 1 \} } \\ { \{ { \tt E q . ~ } 4 \} } \end{array}$   
+7: Obtain attention maps $M ^ { t }$ from $Q ^ { t } , K _ { \mathrm { p } }$ ;   
+8: Obtain $O ^ { t }$ from $M ^ { t }$ , $\{ V _ { i } \}$ , and feed to following layers;   
+9: end for   
+10: end for   
+11: Feed $z ^ { 0 }$ to decoder $\psi ( \cdot )$ to generate $\mathbf { X }$ .
+
+(see Appendix C). However, Stable Diffusion tends to omit objects in generated images (Fig. 1), especially for concept conjunctions that connect two objects with the word “and”. We devise a variant of our method that computes a set of attention maps $\ddot { \mathbb { M } } = \{ M _ { p } ^ { t } , M _ { 1 } ^ { t } , \dots \}$ from $\mathcal { C }$ and multiply them to $\mathbb { V }$ :
+
+$$
+\begin{array} { c } { { \mathbb { K } = \{ f _ { K } ( \mathcal { W } _ { i } ) \} , \mathbb { M } ^ { t } = \{ f _ { M } ( Q ^ { t } , K _ { i } ) \} , i = \mathrm { p } , 1 , 2 , \ldots , k . } } \\ { { O ^ { t } = \displaystyle \frac { 1 } { ( k + 1 ) } \sum _ { i } ( M _ { i } ^ { t } V _ { k } ) , i = \mathrm { p } , 1 , 2 , \ldots , k . } } \end{array}
+$$
+
+$O ^ { t }$ is the output of a certain cross-attention layer and the input into downstream layers to generate final image $x$ . Our algorithm can be summarized as 1, which requires no training or additional data.
+
+# 3 EXPERIMENT
+
+# 3.1 EXPERIMENT SETTINGS
+
+Datasets To address attribute binding and compositional generation, we propose a new benchmark, Attribute Binding Contrast set (ABC-6K). It consists of natural prompts from MSCOCO where each contains at least two color words modifying different objects. We also switch the position of two color words to create a contrast caption (Gardner et al., 2020). We end up with $6 . 4 \mathrm { K }$ captions or 3.2K contrastive pairs. In addition to natural compositional prompts, we challenge our method with less detailed prompts that conjunct two concepts together. These prompts follow the sentence pattern of “a red apple and a yellow banana” and conjunct two objects with their attribute descriptions. We refer to this set of prompts as Concept Conjunction 500 (CC-500). We also evaluate our method on 10K randomly sampled captions from MSCOCO (Lin et al., 2014). We show that our method generalizes beyond attribute binding and introduces no quality degradation for general prompts.
+
+Evaluation Metrics We mainly rely on human evaluations for compositional prompts and concept conjunction (ABC-6K & CC-500). We ask annotators to compare two generated images, from Stable Diffusion and our method respectively, and indicate which image demonstrates better image-text alignment or image fidelity. For image fidelity, we ask the annotators “Regardless of the text, which image is more realistic and natural?”. We also investigate an automatic evaluation metric for image compositions, i.e., using a SOTA phrase grounding model GLIP (Li et al., 2022) to match phraseobject pairs. As for system-level evaluation, we follow previous work to utilize Inception Score (IS) (Salimans et al., 2016), Frechet Inception Distance (FID) (Heusel et al., 2017) and CLIP R-precision ´ (R-prec.) (Park et al., 2021). IS and FID mainly measure the image bank’s systematic quality and diversity, while R-prec measures image-level alignment.
+
+# 3.2 COMPOSITIONAL PROMPTS
+
+Here we show the quantitative and qualitative evaluation results on ABC-6K. We observe that our method sometimes generates very similar images to Stable Diffusion. Hence, we first generate two images per prompt for our method and Stable Diffusion, involving around 12K image pairs to compare. Then, we filter out $20 \%$ of the most similar pairs and then randomly sampled 1500 pairs for human evaluations. As shown in Table 1, annotators indicate around a $42 \%$ chance of our method winning the comparison, $7 \%$ higher than losing the comparison. There is still a $22 \%$ of chance that our images are tied with images from Stable Diffusion.
+
+Table 1: Percentage of generated images of StructureDiffusion that are better than (win), tied with, or worse than (lose) the compared model in terms of text-image alignment and image fidelity. We filtered out $20 \%$ most similar image pairs for comparison (See Sec. E). Composable Diffusion cannot be applied to ABC-6K as those prompts may not contain explicit “and” words that separate concepts.   
+
+<table><tr><td rowspan="2">Benchmark</td><td rowspan="2">StructureDiffusion (ours) v.s.</td><td colspan="3">Alignment</td><td colspan="3">Fidelity</td></tr><tr><td>Win (↑)</td><td>Lose (↓)</td><td>Tie</td><td>Win (↑)</td><td>Lose (↓)</td><td>Tie</td></tr><tr><td>ABC-6K</td><td>Stable Diffusion</td><td>42.2</td><td>35.6</td><td>22.2</td><td>48.3</td><td>39.1</td><td>12.6</td></tr><tr><td rowspan="2">CC-500</td><td>Stable Diffusion</td><td>31.8</td><td>27.7</td><td>38.9</td><td>37.8</td><td>30.6</td><td>31.6</td></tr><tr><td>Composable Diffusion</td><td>46.5</td><td>30.1</td><td>22.8</td><td>61.4</td><td>19.8</td><td>18.8</td></tr></table>
+
+![](images/cde95ccdebc9693de8c741688cd3b4fadc9ef5c3215551ed35f2b60c361cda4c.jpg)  
+Figure 4: Qualitative results on ABC-6K. Our method improves both object-level and scene-level compositionality.
+
+We show qualitative examples characterizing three different perspectives in Fig. 4. Our method fills in the correct color for different parts of an object or different objects, as shown in the first two examples. The third example demonstrates that our method can mitigate the issue of “missing objects”. Among the $42 \%$ winning cases, there are $31 \%$ for “fewer missing objects”, $1 4 . 1 \%$ for “better-matched colors”, and $5 4 . 8 \%$ for “other attributes or details” as indicated by annotators. The results certify that the improvement goes beyond colors to component completeness and fine-grained details. More qualitative examples characterizing all three aspects can be found in Fig. 14 in the Appendix.
+
+# 3.3 CONCEPT CONJUNCTION
+
+Here we address challenging concept conjunction prompts and evaluate our method on CC-500. Apart from Stable Diffusion, we also compare to Composable Diffusion (Liu et al., 2022) implemented on top of Stable Diffusion. For Composable Diffusion, we separate the prompts into text segments by the keyword “and” and feed each span into an independent diffusion process. We generate three images per prompt and use all images for human evaluation for Stable Diffusion. We randomly sampled 600 images for comparison to Composable Diffusion.
+
+<table><tr><td rowspan="2"></td><td colspan="6">CC-500 (Prompt format: “a [colorA] [objectA] and a [colorB] [objectB]&quot;)</td></tr><tr><td></td><td>Human Annotations</td><td></td><td>GLIP</td><td></td><td>Human-GLIP</td></tr><tr><td>Methods</td><td>Zero/One obj. ()</td><td>Two obj.</td><td>Two obj. w/ correct colors</td><td>Zero/One obj.(↓)</td><td>Two obj.</td><td>Consistency</td></tr><tr><td>Stable Diffusion</td><td>65.5</td><td>34.5</td><td>19.2</td><td>69.0</td><td>31.0</td><td>46.4</td></tr><tr><td>Composable Diffusion</td><td>69.7</td><td>30.3</td><td>20.6</td><td>74.2</td><td>25.8</td><td>48.9</td></tr><tr><td>StructureDiffusion (Ours)</td><td>62.0</td><td>38.0</td><td>22.7</td><td>68.8</td><td>31.2</td><td>47.6</td></tr></table>
+
+Table 2: Fine-grained human and automatic evaluation results on CC-500. Recall that each prompt is a conjunction of two different objects with different colors. “Zero/One obj.” means that the model fails to generate all desired objects in the image. “Human-GLIP consistency” reflects the percentage of images where human annotations align with GLIP detection results.
+
+![](images/3902d5a9c111e4d4a12e67c65e27de1a9c2c07d74efa1fca4dfa19aefa3dbcb9.jpg)  
+Figure 5: Qualitative results on CC-500 prompts that emphasize two aspects. (a) Color leakage: our method prevents the green color from invading the bird or apple. (b) Missing objects: our method completes the “blue bowl” and improves the quality of the “blue apple”.
+
+As shown in Table 1, our method outperforms Stable Diffusion by around $4 . 1 \%$ and Composable Diffusion by $1 6 . 4 \%$ in terms of image-text alignment. We also observe that our method enhances some fine-grained details in the generated images, leading to a $7 . 2 \%$ improvement in image fidelity when compared with Stable Diffusion. We observe that images from composable diffusion can be oversaturated with unnatural visual textures and layouts, which could be the reason for StructureDiffusion to have high win rate in image fidelity. As shown in Fig. 5 and Fig. 13. Our approach prevents color bleeding (left), missing objects (right) and strengthens details (right).
+
+To further quantify the text-image alignment, we consider both human annotations and automatic evaluations. For each object mentioned in the prompt, we ask annotators whether the object exists in the image and whether it is in the correct color. We also apply a state-of-the-art detection model GLIP (Li et al., 2022) to ground each “a [color] [object]” phrase into bounding boxes. We report the percentage of images that contain incomplete objects / complete objects / complete objects with correct colors in Table 2. StructureDiffusion improves the compositionality by $3 . 5 \%$ based on human annotations while only $0 . 2 \%$ based on GLIP. We discover that humans disagree with GLIP for more than $50 \%$ of the images, as entailed by the low consistency rate. Previous work also suggests the deficiency of large pre-trained models in compositional understanding (Thrush et al., 2022).
+
+# 3.4 OTHER PROMPTS
+
+We show that our StructureDiffusion maintain the overall image quality and diversity on general prompts. We follow the standard evaluation process and generate 10,000 images from randomly
+
+![](images/e0cc7567ff201cd421e0f017febca9fe7cd7bc251c12c2c41f6a6f273c0b81cb.jpg)  
+Figure 6: Qualitative results of using scene graph parser to generate structured representations.
+
+![](images/7dfce557e99a420d3ccd8d1cf8e3979db4bd6ad9b3761a1fd404947bf41071bb.jpg)  
+Figure 7: Ablation study on the text sequence embeddings. We find that the padding embeddings are fully contextualized, representing the prompt’s high-level semantics. However, not all padding tokens are necessary to maintain a high-fidelity output from Stable Diffusion.
+
+sampled MSCOCO captions. Stable Diffusion obtains 39.9 IS, 18.0 FID and 72.2 R-Precision. Our method achieves 40.9 IS, 17.9 FID and $7 2 . 3 \mathrm { R }$ -Precision. StructureDiffusion maintains the image fidelity and diversity as indicated in the comparable IS/FID/R-Prec scores.
+
+# 3.5 SCENE GRAPH INPUT
+
+We show that our method is not limited to constituency parsing but can also be extended to other structured representations, such as scene graphs. As shown in Fig. 6, we first adopt the scene graph parser (Wu et al., 2019) and obtain a graph like the ones next to each image from the input prompt. The parser returns basic entities and their relations in between. We extract text spans of basic entities with their attributes attached and text spans that include two related entities. We provide examples in Appendix 3 and make comparison to the constituency parser. Similarly, we encode these spans separately and re-align each with the entire prompt encoding sequence. On MS-COCO, the scene graph parser setting maintains the image quality with 39.2 IS, 17.9 FID, and 72.0 R-Precision. When compared to Stable Diffusion on ABC-6K, the scene graph parser achieves $3 4 . 2 \% - 3 2 . 9 \% - 3 2 . 9 \%$ Win-Lose-Tie in image-text alignment and $3 4 . 5 \% - 3 2 . 5 \% - 3 3 . 0 \%$ Win-Lose-Tie in image fidelity. As for CC-500, the scene graph parser leads to the same output images due to the same text spans. We refer to Table 3 and Fig. 12 for more results and comparison.
+
+# 4 ABLATION STUDY
+
+# 4.1 RE-ALIGNING SEQUENCE
+
+In Section 2, we describe a method to realign the encoding of a text span back into the sequence of the full prompt. Since the noun-phrase text spans are shorter than the full sequence, re-alignment ensures that each token’s value vector corresponds to the correct attention map. On the other hand, naively expanding the span to the length of the full sequence degrades the image quality by ${ \sim } 2 \mathrm { I S } /$ FID (37.5 IS, 19.8 FID) compared to images with re-alignment or Stable Diffusion.
+
+# 4.2 CONTEXTUALIZED TEXT EMBEDDINGS
+
+One limitation brought by our StructureDiffusion is that the cross-attention computation costs increase by the number of noun phrases. Yet we noticed that most of the attention maps are computed from padding embeddings, as Stable Diffusion adopts CLIP text encoders and automatically pads the sequence to 77 tokens. We conjecture that not all padding tokens are necessary for generating high-quality images. As is shown in Fig. 7, we study four different patterns of token embeddings. We discover that leaving the nearest padding embeddings maintains a similar IS / FID score as the full sequence. Further removing this padding embedding results in apparent degradation. While only using the nearest padding embedding results in the worst image quality, we find that the high-level image layout and semantics are preserved (see bottom right of Fig. 7). This phenomenon indicates that the padding embeddings are fully contextualized with the full prompt semantics. This also justifies our re-alignment operation that preserves padding embeddings of the main sequence ${ \mathcal { W } } _ { \mathrm { f u l l } }$ .
+
+# 5 RELATED WORK
+
+Text-to-Image Synthesis The diffusion model is an emerging type of model that generate highquality images with a much more stable training process (Song & Ermon, 2019; Ho et al., 2020). Rombach et al. (2022) proposes to encode an image with an autoencoder and then leverage a diffusion model to generate continuous feature maps in the latent space. Stable Diffusion Rombach et al. (2022) adopts similar architecture but is trained on large-scale image-text datasets with fixed CLIP text encoder. Imagen (Saharia et al., 2022) addresses the importance of language understanding by using a frozen T5 encoder (Raffel et al., 2020), a dedicated large language model. We mainly focus on diffusion models and conduct our experiments on Stable Diffusion (Rombach et al., 2022), the SOTA open-sourced T2I model.
+
+Compositional Generation The compositional or controllable generation has been an essential direction for T2I models to understand and disentangle basic concepts in the generation process. As text inputs are relatively weak conditions, previous work leverage layout or scene graph to enhance compositionality (Johnson et al., 2018; Hong et al., 2018; Yang et al., 2022; Gafni et al., 2022). More recently, Liu et al. (2022) proposes an approach where the concept conjunctions are achieved by adding estimated scores from a parallel set of diffusion processes. In contrast, our method can be directly merged into the cross-attention layers with much less computational overhead.
+
+Diffusion Guidance Ho & Salimans (2022) develops classifier-free guidance where a single diffusion model is jointly trained under conditional and unconditional inputs. Most large-scale SOTA models, including autoregressive ones, adopt this technique for flexible and improved conditional synthesis results (Rombach et al., 2022; Ramesh et al., 2022; Gafni et al., 2022; Yu et al., 2022; Saharia et al., 2022). Hertz et al. (2022) discovers unique properties of cross attention maps on Imagen (Saharia et al., 2022) and achieves structure-preserving image editing by manipulating these maps. We observe similar properties in Stable Diffusion (Rombach et al., 2022) but propose a different algorithm for fine-grained, compositional text-to-image generation.
+
+# 6 CONCLUSION
+
+In this work, we propose a training-free method for compositional text-to-image generation. First, we observe that existing large-scale T2I diffusion models can still struggle in compositional image synthesis. We address this challenge by explicitly focusing on binding objects with the correct attributes. Second, we propose structured diffusion guidance incorporating language structures into the cross-attention layers. We propose two simple techniques to align the structured encoding with the attention maps. Using our structured guidance on Stable Diffusion, attributes can be bound more accurately while maintaining the overall image quality and diversity. In addition, we justify our approach by conducting an in-depth analysis of the frozen language encoder and attention maps. Future work may explore explicit approaches to generate plausible image layouts without missing components. We hope that our approach accelerates the development of interpretable and efficient methods for diffusion-based text-to-image models.
+
+# ACKNOWLEDGEMENT
+
+We would like to thank the Robert N. Noyce Trust for their generous gift to the University of California via the Noyce Initiative. The work was also partially funded by an unrestricted gift from Google and by the National Science Foundation award #2048122. The writers’ opinions and conclusions in this publication are their own and should not be construed as representing the sponsors’ official policy, expressed or inferred.
+
+# REPRODUCIBILITY STATEMENT
+
+We release our core codebase containing the methodology implementation, settings, benchmarks containing compositional prompts under supplementary materials.
+
+# ETHICAL STATEMENT
+
+As for the data collection and verification, we use the Amazon Mechanical Turk platform and form the comparison task as batches of HITs. We select workers from English-speaking countries, including the US, CA, UK, AU, and NZ, since the task require understanding the English input prompt. Each HIT takes around 15-30 seconds on average to accomplish, and we pay each submitted HIT with 0.15 US dollars, resulting in an hourly payment of 18 US dollars.
+
+# REFERENCES
+
+Prafulla Dhariwal and Alexander Nichol. Diffusion models beat gans on image synthesis. Advances in Neural Information Processing Systems, 34:8780–8794, 2021.
+
+Ming Ding, Wendi Zheng, Wenyi Hong, and Jie Tang. Cogview2: Faster and better text-to-image generation via hierarchical transformers. arXiv preprint arXiv:2204.14217, 2022.
+
+Alaaeldin El-Nouby, Shikhar Sharma, Hannes Schulz, Devon Hjelm, Layla El Asri, Samira Ebrahimi Kahou, Yoshua Bengio, and Graham W.Taylor. Tell, Draw, and Repeat: Generating and Modifying Images Based on Continual Linguistic Instruction. In ICCV, 2019.
+
+Tsu-Jui Fu, Xin Eric Wang, Scott Grafton, Miguel Eckstein, and William Yang Wang. SSCR: Iterative Language-Based Image Editing via Self-Supervised Counterfactual Reasoning. In EMNLP, 2020.
+
+Oran Gafni, Adam Polyak, Oron Ashual, Shelly Sheynin, Devi Parikh, and Yaniv Taigman. Make-ascene: Scene-based text-to-image generation with human priors. arXiv preprint arXiv:2203.13131, 2022.
+
+Matt Gardner, Yoav Artzi, Victoria Basmov, Jonathan Berant, Ben Bogin, Sihao Chen, Pradeep Dasigi, Dheeru Dua, Yanai Elazar, Ananth Gottumukkala, et al. Evaluating models’ local decision boundaries via contrast sets. Findings of Empirical Methods in Natural Language Processing, 2020.
+
+Shuyang Gu, Dong Chen, Jianmin Bao, Fang Wen, Bo Zhang, Dongdong Chen, Lu Yuan, and Baining Guo. Vector quantized diffusion model for text-to-image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10696–10706, 2022a.
+
+Shuyang Gu, Dong Chen, Jianmin Bao, Fang Wen, Bo Zhang, Dongdong Chen, Lu Yuan, and Baining Guo. Vector quantized diffusion model for text-to-image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10696–10706, 2022b.
+
+Amir Hertz, Ron Mokady, Jay Tenenbaum, Kfir Aberman, Yael Pritch, and Daniel Cohen-Or. Promptto-prompt image editing with cross attention control. arXiv preprint arXiv:2208.01626, 2022.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural information processing systems, 30, 2017.
+
+Jonathan Ho and Tim Salimans. Classifier-free diffusion guidance. arXiv preprint arXiv:2207.12598, 2022.
+
+Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems, 33:6840–6851, 2020.
+
+Seunghoon Hong, Dingdong Yang, Jongwook Choi, and Honglak Lee. Inferring semantic layout for hierarchical text-to-image synthesis. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 7986–7994, 2018.
+
+Justin Johnson, Agrim Gupta, and Li Fei-Fei. Image generation from scene graphs. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1219–1228, 2018.
+
+Doyup Lee, Chiheon Kim, Saehoon Kim, Minsu Cho, and Wook-Shin Han. Autoregressive image generation using residual quantization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 11523–11532, 2022.
+
+Bowen Li, Xiaojuan Qi, Thomas Lukasiewicz, and Philip Torr. Controllable text-to-image generation. Advances in Neural Information Processing Systems, 32, 2019.
+
+Liunian Harold Li, Pengchuan Zhang, Haotian Zhang, Jianwei Yang, Chunyuan Li, Yiwu Zhong, Lijuan Wang, Lu Yuan, Lei Zhang, Jenq-Neng Hwang, et al. Grounded language-image pre-training. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10965–10975, 2022.
+
+Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014.
+
+Luping Liu, Yi Ren, Zhijie Lin, and Zhou Zhao. Pseudo numerical methods for diffusion models on manifolds. In International Conference on Learning Representations, 2021a.
+
+Nan Liu, Shuang Li, Yilun Du, Antonio Torralba, and Joshua B Tenenbaum. Compositional visual generation with composable diffusion models. arXiv preprint arXiv:2206.01714, 2022.
+
+Xihui Liu, Dong Huk Park, Samaneh Azadi, Gong Zhang, Arman Chopikyan, Yuxiao Hu, Humphrey Shi, Anna Rohrbach, and Trevor Darrell. More control for free! image synthesis with semantic diffusion guidance. arXiv preprint arXiv:2112.05744, 2021b.
+
+Chao Lou, Wenjuan Han, Yuhuan Lin, and Zilong Zheng. Unsupervised vision-language parsing: Seamlessly bridging visual scene graphs with language structures via dependency relationships. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 15607–15616, June 2022.
+
+Alex Nichol, Prafulla Dhariwal, Aditya Ramesh, Pranav Shyam, Pamela Mishkin, Bob McGrew, Ilya Sutskever, and Mark Chen. Glide: Towards photorealistic image generation and editing with text-guided diffusion models. ICML, 2021.
+
+Dong Huk Park, Samaneh Azadi, Xihui Liu, Trevor Darrell, and Anna Rohrbach. Benchmark for compositional text-to-image synthesis. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 1), 2021.
+
+Peng Qi, Yuhao Zhang, Yuhui Zhang, Jason Bolton, and Christopher D. Manning. Stanza: A Python natural language processing toolkit for many human languages. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: System Demonstrations, 2020.
+
+Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International Conference on Machine Learning, pp. 8748–8763. PMLR, 2021.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1–67, 2020. URL http://jmlr.org/papers/v21/20-074.html.
+
+Aditya Ramesh, Mikhail Pavlov, Gabriel Goh, Scott Gray, Chelsea Voss, Alec Radford, Mark Chen, and Ilya Sutskever. Zero-shot text-to-image generation. In International Conference on Machine Learning, pp. 8821–8831. PMLR, 2021.
+
+Aditya Ramesh, Prafulla Dhariwal, Alex Nichol, Casey Chu, and Mark Chen. Hierarchical textconditional image generation with clip latents. arXiv preprint arXiv:2204.06125, 2022.
+
+Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Bjorn Ommer. High- ¨ resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10684–10695, 2022.
+
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computerassisted intervention, pp. 234–241. Springer, 2015.
+
+Nataniel Ruiz, Yuanzhen Li, Varun Jampani, Yael Pritch, Michael Rubinstein, and Kfir Aberman. Dreambooth: Fine tuning text-to-image diffusion models for subject-driven generation. arXiv preprint arXiv:2208.12242, 2022.
+
+Chitwan Saharia, William Chan, Saurabh Saxena, Lala Li, Jay Whang, Emily Denton, Seyed Kamyar Seyed Ghasemipour, Burcu Karagol Ayan, S Sara Mahdavi, Rapha Gontijo Lopes, et al. Photorealistic text-to-image diffusion models with deep language understanding. arXiv preprint arXiv:2205.11487, 2022.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. Advances in neural information processing systems, 29, 2016.
+
+Sebastian Schuster, Ranjay Krishna, Angel Chang, Li Fei-Fei, and Christopher D Manning. Generating semantically precise scene graphs from textual descriptions for improved image retrieval. In Proceedings of the fourth workshop on vision and language, pp. 70–80, 2015.
+
+Yang Song and Stefano Ermon. Generative modeling by estimating gradients of the data distribution. Advances in Neural Information Processing Systems, 32, 2019.
+
+Ming Tao, Hao Tang, Fei Wu, Xiao-Yuan Jing, Bing-Kun Bao, and Changsheng Xu. Df-gan: A simple and effective baseline for text-to-image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 16515–16525, 2022.
+
+Tristan Thrush, Ryan Jiang, Max Bartolo, Amanpreet Singh, Adina Williams, Douwe Kiela, and Candace Ross. Winoground: Probing vision and language models for visio-linguistic compositionality. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 5238–5248, 2022.
+
+Bo Wan, Wenjuan Han, Zilong Zheng, and Tinne Tuytelaars. Unsupervised vision-language grammar induction with shared structure modeling. In International Conference on Learning Representations, 2021.
+
+Hao Wu, Jiayuan Mao, Yufeng Zhang, Yuning Jiang, Lei Li, Weiwei Sun, and Wei-Ying Ma. Unified visual-semantic embeddings: Bridging vision and language with structured meaning representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6609–6618, 2019.
+
+Zuopeng Yang, Daqing Liu, Chaoyue Wang, Jie Yang, and Dacheng Tao. Modeling image composition for complex scene generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 7764–7773, 2022.
+
+Jiahui Yu, Yuanzhong Xu, Jing Yu Koh, Thang Luong, Gunjan Baid, Zirui Wang, Vijay Vasudevan, Alexander Ku, Yinfei Yang, Burcu Karagol Ayan, et al. Scaling autoregressive models for contentrich text-to-image generation. arXiv preprint arXiv:2206.10789, 2022.
+
+Han Zhang, Jing Yu Koh, Jason Baldridge, Honglak Lee, and Yinfei Yang. Cross-modal contrastive learning for text-to-image generation. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 833–842, 2021.
+
+Yiwu Zhong, Liwei Wang, Jianshu Chen, Dong Yu, and Yin Li. Comprehensive image captioning via scene graph decomposition. In European Conference on Computer Vision, pp. 211–229. Springer, 2020.
+
+Yufan Zhou, Ruiyi Zhang, Changyou Chen, Chunyuan Li, Chris Tensmeyer, Tong Yu, Jiuxiang Gu, Jinhui Xu, and Tong Sun. Towards language-free training for text-to-image generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 17907–17917, 2022.
+
+Minfeng Zhu, Pingbo Pan, Wei Chen, and Yi Yang. Dm-gan: Dynamic memory generative adversarial networks for text-to-image synthesis. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 5802–5810, 2019.
+
+# A RELATED WORK
+
+Text-to-Image Synthesis There are mainly three types of models for text-to-image synthesis: GAN-based (Tao et al., 2022; Zhu et al., 2019; Li et al., 2019; Fu et al., 2020; El-Nouby et al., 2019), autoregressive (Gu et al., 2022b; Lee et al., 2022; Ding et al., 2022) and diffusion models (Liu et al., 2021b; Nichol et al., 2021; Ruiz et al., 2022). Zhang et al. (2021) proposes XMC-GAN, a one-stage GAN that employs multiple contrastive losses between image-image, image-text, and region-token pairs. More recently, LAFITE (Zhou et al., 2022) enables language-free training by constructing pseudo image-text feature pairs using CLIP (Radford et al., 2021). As for autoregressive models, DALL-E adopts VQ-VAE to quantize image patches into tokens and then uses a transformer to generate discrete tokens sequentially (Ramesh et al., 2021). Parti (Yu et al., 2022) and Make-A-Scene (Gafni et al., 2022) both leverage classifier-free guidance to improve controllability. As for diffusion models, Gu et al. (2022a) concatenates VQ-VAE with the diffusion model and shows that the diffusion process can operate in discrete latent space. DALL-E 2 adopts the CLIP text encoder so that the diffusion process inverts the textual features into images (Ramesh et al., 2022).
+
+Structured Representations for Vision and Language Inferring shared structures across language and vision has been a long-term pursuit in unifying these modalities (Schuster et al., 2015; Johnson et al., 2018; Zhong et al., 2020; Lou et al., 2022). Wu et al. (2019) utilizes the structure from semantic parsing in a visual-semantic embedding framework to facilitate embedding learning. Wan et al. (2021) proposes a new task in which the goal is to learn a joint structure between semantic parsing and image regions. To the best of our knowledge, our work is the first attempt in T2I to incorporate language structures into the image synthesizing process.
+
+Diffusion Guidance To convert an unconditional diffusion model into a class-conditional one, Dhariwal & Nichol (2021) input the noisy image from each step into a classifier and calculate the classification loss. The loss can be back-propagated to the image space to provide a gradient that marginalizes the score estimation from the log of conditional probability. Similarly, in the T2I subdomain, Liu et al. (2021b) and Nichol et al. (2021) apply a noisy CLIP model to measure the cosine similarity between text prompts and noisy images.
+
+# B IMPLEMENTATION DETAILS
+
+Throughout the experiments, we implement our method upon Stable Diffusion v1.4. For all comparisons between our method and Stable Diffusion, we fix the seed to generate the same initial Gaussian map and use 50 diffusion steps with PLMS sampling (Liu et al., 2021a). We fix the guidance scale to 7.5 and equally weight the key-value matrices in cross-attention layers if not otherwise specified. We do not add hand-crafted prompts such as “a photo of” to the text input. We use the Stanza Library (Qi et al., 2020) for constituency parsing and obtain noun phrases if not otherwise specified.
+
+# C VISUALIZATION OF ATTENTION MAPS
+
+In this section, we demonstrate the visualization of cross-attention maps to support our assumptions and claims in Sec. 2. As is shown in Fig. 8, the attention maps of Stable Diffusion and our method have similar spatial distribution and highlights throughout the diffusion process. This phenomenon supports our assumption in Sec. 2.2 that the attention map $M _ { t }$ is unchanged even with multiple values in each cross-attention layer. We can observe a similar phenomenon in Fig. 9 except that our method accelerates the formation of interpretable attentions for both “green” and “clock” tokens.
+
+![](images/e22e2d5e7ace9b5fbcfe4a7cc12e67be8180444f5dc3271034867469bdbfde5a.jpg)  
+Figure 8: Visualization of cross attention maps of Stable Diffusion and our method. We compare maps of multiple tokens throughout the whole diffusion process with equal intervals.
+
+Fig. 8, 9 also justify our claim that values represent rich textual semantics mapped to the image space as contents. For instance, our method parses the prompt in Fig. 8 into “A long narrow yellow kitchen” and “black and white floor tiles”, encodes and aligns them separately to form V. Empirically, these operations enhance the semantics of “yellow” and “black and white” separately and mitigate “yellow” being blended into “black and white”. This explains the disappearance of color leakage in our image compared to Stable Diffusion. Though one may attribute the leakage to incorrect attention distribution of the “yellow” token, we argue that this is not the critical reason. Despite the attention maps of “yellow” from our method slightly highlighting the “floor tile” regions, we cannot observe any yellow in our generated image. This proves that inaccurate attention distributions contribute little to the final image content. In addition, we also show in Fig. 10 that using multiple Keys is able to rectify the image layouts to mitigate missing object issues. The sheep-like attention maps in the third row verify the proposed variants of our method for concept conjunctions.
+
+![](images/0be7b80d0f76ab47ff37221209affb8a234d6aaf76276fa61011c736050abb18.jpg)  
+Figure 9: Visualization of cross attention maps corresponding to token “green” and “clock” across the full diffusion timestamps from step 50 to step 1 in equal intervals. Red boxes highlight steps where our method accelerates the formation of correct attention on the clock region. The evolution of the token “green” is also more interpretable in our method. Although the image composition is imperfect, the visualization still supports our assumptions and claims in Sec. 2.2.
+
+![](images/6ce94909eda492a7e78221376ea5b39def302a7a1f5a92084ca40943ea3a1fda.jpg)  
+Figure 10: Visualization of attention maps for token “sheep” of different methods. Our method with multiple Keys successfully rectify image layouts.
+
+# D ABLATION STUDY
+
+# D.1 A CASE STUDY OF ATTRIBUTE BINDING
+
+Here, we present a case study to show evidence of two root causes of incorrect attribute binding. The first one is the contextualized token embeddings due to causal attention masks. As is shown on the left side of Fig. 11, we first encode two different prompts with a shared component, e.g. “a red apple” as the naive one and “a green bag and a red apple”. Using the encoding sequence of the naive prompt, we are able to get an image of red apple only. It is reasonable to assume that the yellow green regions are natural results of learning from authentic apple images. Then, we replace the tokens of the naive prompt with embeddings of the same token from the more complicated prompt. We use the same gaussian noise as initialization and generate an unnatural image with a solid green region (in the yellow bounding box). This result proves that the token “red” is contaminated with the semantics of “green” before it and explains some images with color leakage problems (e.g., Fig. 1).
+
+![](images/3523608906863534f4a3e158ef3281942b6bb6822477164e5d40472b91acf880.jpg)  
+Figure 11: Examples showing the potential root causes of incorrect attribute binding. Left: The large green regions in the second image prove that the hidden state’s output of token “red” is contextualized with token “green” before it. Right: Visualization of attention maps showing that the semantics from the token “bird” is mistakenly attended to the mouth region of the bear. The final image shows the unnatural beak-like shape of the bear.
+
+The second reason attributes to inaccurate attention maps. In Fig. 11 (right), we visualize five crossattention maps (averaged across attention heads) from both downsample and upsampling blocks. The attention maps show the salient regions corresponding to the token “bird”. These maps demonstrate highlighted regions in the bottom left corner where the bird is located in the final image. Despite the interpretable structures, the maps also show saliency around the mouth region of the bear across all five layers. Thus, the inaccurate attention maps lead to a beak-like mouth of the bear in the image.
+
+# D.2 COMPARISON OF PARSERS
+
+In this subsection, we compare the difference between using a constituency parser and a scene graph parser to obtain text spans and generate images. Table 3 compares the extracted text spans using constituency parser and scene graph parser. Example 0 shows that both parsers end up with the same results for CC-500 prompts. For Example 1-4, the scene graph parser generates more spans than the constituency parser. We notice that concepts in the middle of the sentence appear more often in these spans than other noun tokens, like “egg” or “red sauce” in Example 3. This imbalance potentially explains why the “egg” looks more highlighted in Fig. 12 (bottom left). On the other hand, “orange slices” appear more often in constituency parsing results, leading to better “orange” textures in the generated image. Similar observations can be made in Example 2, where “green pole” is emphasized more often by the constituency parser.
+
+# E LIMITATIONS & FUTURE WORK
+
+There are several limitations of our work. First of all, our method depends on an external parsing function that may not be perfect. We adopt the commonly used Stanza Library Qi et al. (2020) for constituency parsing. The parsing function can be replaced with a more advanced learning-based method for improvement. Secondly, our method mainly focuses on compositional T2I neglecting any style descriptions. The parsing mechanism may categorize a style description, e.g. “in Van Gogh style” as a separate noun phrase that cannot be grounded in the image space. In addition, we discover that StructureDiffusion tends to generate similar images as Stable Diffusion. Thus we filtered out $20 \%$ of most similar image pairs in Table 1, considering the efficiency of human evaluation. Therefore, the improvement could be compromised when evaluated on the full set of generated images. Future work may focus on devising explicit methods to associate attributes to objects using spatial information as input. For example, how to make a text-to-image synthesis model interpret coordinate information with limited fine-tuning or prompt tuning steps would be an appealing direction.
+
+Table 3: Comparison between the constituency parser and scene graph parser. For CC-500 prompts, both parsers end up with the same results. As for general prompts, scene graph parser tends to generate more text spans with middle concepts appearing multiple times across different spans.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Constituency Parser</td><td rowspan=1 colspan=1>Scene Graph Parser</td></tr><tr><td rowspan=2 colspan=1>Example 0</td><td rowspan=1 colspan=2>CC-500 Prompt: A white sheep and a red car</td></tr><tr><td rowspan=1 colspan=1>“A white sheep”,“a red car”</td><td rowspan=1 colspan=1>“A white sheep”,“a red car”</td></tr><tr><td rowspan=2 colspan=1>Example 1</td><td rowspan=1 colspan=2>Prompt: A silver car with a black cat sleeping on top of it</td></tr><tr><td rowspan=1 colspan=1>“A silver car”,“a black cat”,“A silver car with a black cat”</td><td rowspan=1 colspan=1>“A silver car”,&quot;a black cat”,“top of it”,“a black cat sleeping on top of it&quot;</td></tr><tr><td rowspan=2 colspan=1>Example 2</td><td rowspan=1 colspan=2>Prompt:A horse running in a white field next to a black and green pole</td></tr><tr><td rowspan=1 colspan=1>“Ahorse”,“a white feld&quot;,“a black and green pole&quot;,“a white field next to a black and green pole”</td><td rowspan=1 colspan=1>“Ahorse”,“a white field”,“a black and green pole”,“A horse running in a white field&quot;</td></tr><tr><td rowspan=2 colspan=1>Example 3</td><td rowspan=1 colspan=2>Prompt:Rice with red sauce with eggs over the top and orange slices on the side</td></tr><tr><td rowspan=1 colspan=1>“red sauce”,“the side”,“the top and orange slices”,“the top and orange slices on the side&quot;</td><td rowspan=1 colspan=1>“red sauce”,“the side”,“the top and orange slices”,“Rice with red sauce”,“red sauce with eggs”,“the top and orange slices on the side&quot;,“red sauce with eggs over the top and orange slices”</td></tr><tr><td rowspan=2 colspan=1>Example 4</td><td rowspan=1 colspan=2>Prompt:A pink scooter with a black seat next to a blue car</td></tr><tr><td rowspan=1 colspan=1>“A pink scooter”,“a black seat”,“a blue car”</td><td rowspan=1 colspan=1>“A pink scooter”,“a black seat”,“a blue car”,&quot;a pink scooter with a black seat&quot;,“a black seat next to a blue car”</td></tr></table>
+
+![](images/5505e9c9fabb63da9b36d9e776d538f607231efc48fb6c2f6bc627e1951a2d11.jpg)  
+Figure 12: Synthesized images corresponding to prompts in Table 3. Yellow boxes annotate compositions that are improved using different parsers.
+
+![](images/9a323a017b67c428078490d9067e77f606d8f54878028c43b59103d5e505fc9b.jpg)  
+Figure 13: Qualitative results on CC-500
+
+# Stable Diffusion
+
+# Ours
+
+# Stable Diffusion
+
+# Ours
+
+# Stable Diffusion
+
+# Ours
+
+a purple cat with a orange hat on its head
+
+A red cat sits on a rug with a black cord
+
+A yellow cat is wearing a blue plastic baseball hat.
+
+![](images/660bc275b91b59866cd20e3a88baefb5a552b3ad21116d920fca9476c0987944.jpg)
+
+![](images/44f8df4e6174cfaee77c876deda6de6350198075800255d17326b31cbf9a0166.jpg)
+
+![](images/26a9991969c15534788eae2f5acc0d8cda40c915d13508aea40a64234a837dfe.jpg)  
+A red helmet is on a yellow toilet in the dirt
+
+A red stop sign above a white walk across road sign
+
+Two elephants walking by a green wall with tan palm trees painted on it
+
+![](images/cfd38b6e692be180d8d214269d4b921af9c6ea51e92262d22844436ebebe2b8b.jpg)
+
+![](images/408e26c582eccff899a6069e2265d99daf61980c8cc47f66c6c8328d8054ffd6.jpg)
+
+![](images/7c5f1e143277e8913a928bce5fd0f6aacb27ceb05fed39986d71058a5a715923.jpg)
+
+# A bathroom with red tile and a green shower curtain
+
+A spacious kitchen has white walls , red countertops , and a large stove
+
+A large white bed sitting in a hotel room next to a red couch
+
+![](images/4a43f884cd58a3781a856b40d946e06aa95a3781630c49ecd2683d6082a67e4e.jpg)
+
+![](images/91f6e969166829de16eb4f631fbb73f19ef0d5390410d037d4a690f99df02786.jpg)
+
+![](images/c40deaf2eb3b4751d7c5816cee4083bcc77c9b78e322402b3ca26513daf3706d.jpg)
+
+A pink towel stands out greatly in the white bathroom
+
+![](images/bacd240485e26a532174d993863ebd922208a129b432bdb6bcd36b94119a092b.jpg)  
+A white toilet bowl with a purple rug in front
+
+# A large pizza on a white plate sitting on a blue table
+
+![](images/fc3d8bd9df11cad37a11762b0e2c5fd1165c80053f07eca502b775632458b10e.jpg)
+
+![](images/48b52b815f2fadf7e93602f86d613241414c34c280fa91397edfec9c1c36a9c5.jpg)
+
+A spoon and bowl of red pea soup and green beans with onions
+
+A cow standing outside of a white building with a blue entrance
+
+A black and white curtain   
+hanging in a room that is   
+decorated in black, white and   
+red
+
+![](images/b7fd1fb2b097479ee0c8daa0225ada709939a000e386f9227ee3d53632006091.jpg)
+
+![](images/6fd1de4853b4e135bbd29c014613e0ba1aebc6158a4201d581f5433d4629e15d.jpg)
+
+![](images/d5d8e5dbed72e828a9bba99342c7933385ffcda9b12e7d2758d88218380089c8.jpg)  
+Figure 14: Qualitative results on ABC-6K
+
+![](images/cfdda3c5e52b24145788d8db72809206b16643bae64a24cf322cb9114b08223e.jpg)  
+Figure 15: Qualitative results characterizing attributes beyond colors, including shape, size and materials.
+
+![](images/228590b790dbd98fc2e4f38e8af5d5b6c518ba667976fe594af7a5e67dfcd7e5.jpg)  
+Figure 16: A prompt “an astronaut riding a horse” appended with different (combinations of) style descriptions. Our method has no negative effects on the image style. “base” refers to Stable Diffusion.

parse/dev/PUIqjT4rzq7/PUIqjT4rzq7_content_list.json

@@ -0,0 +1,2214 @@
+[
+    {
+        "type": "text",
+        "text": "TRAINING-FREE STRUCTURED DIFFUSION GUIDANCE FOR COMPOSITIONAL TEXT-TO-IMAGE SYNTHESIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Weixi Feng1, Xuehai $\\mathbf { H e } ^ { 2 }$ , Tsu-jui $\\mathbf { F u } ^ { 1 }$ , Varun Jampani3, Arjun Akula3, Pradyumna Narayana3, Sugato Basu3, Xin Eric Wang2, William Yang Wang1 1University of California, Santa Barbara, 2University of California, Santa Cruz, 3Google ",
+        "bbox": [
+            184,
+            169,
+            764,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Large-scale diffusion models have achieved state-of-the-art results on text-to-image synthesis (T2I) tasks. Despite their ability to generate high-quality yet creative images, we observe that attribution-binding and compositional capabilities are still considered major challenging issues, especially when involving multiple objects. Attribute-binding requires the model to associate objects with the correct attribute descriptions, and compositional skills require the model to combine and generate multiple concepts into a single image. In this work, we improve these two aspects of T2I models to achieve more accurate image compositions. To do this, we incorporate linguistic structures with the diffusion guidance process based on the controllable properties of manipulating cross-attention layers in diffusion-based T2I models. We observe that keys and values in cross-attention layers have strong semantic meanings associated with object layouts and content. Therefore, by manipulating the cross-attention representations based on linguistic insights, we can better preserve the compositional semantics in the generated image. Built upon Stable Diffusion, a SOTA T2I model, our structured cross-attention design is efficient that requires no additional training samples. We achieve better compositional skills in qualitative and quantitative results, leading to a significant $5- 8 \\%$ advantage in head-to-head user comparison studies. Lastly, we conduct an in-depth analysis to reveal potential causes of incorrect image compositions and justify the properties of cross-attention layers in the generation process. ",
+        "bbox": [
+            233,
+            281,
+            766,
+            559
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            585,
+            336,
+            602
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Text-to-Image Synthesis (T2I) is to generate natural and faithful images given a text prompt as input. Recently, there has been a significant advancement in the quality of generated images by extremely large-scale vision-language models, such as DALL-E 2 (Ramesh et al., 2022), Imagen (Saharia et al., 2022), and Parti (Yu et al., 2022). In particular, Stable Diffusion (Rombach et al., 2022) is the state-of-the-art open-source implementation showing superior evaluation metric gains after training over billions of text-image pairs. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In addition to generating high-fidelity images, the ability to compose multiple objects into a coherent scene is also essential. Given a text prompt from the user end, T2I models need to generate an image that contains all necessary visual concepts as mentioned in the text. Achieving such ability requires the model to understand both the full prompt and individual linguistic concepts from the prompt. As a result, the model should be able to combine multiple concepts and generate novel objects that have never been included in the training data. In this work, we mainly focus on improving the compositionality of the generation process, as it is essential to achieve controllable and generalized text-to-image synthesis with multiple objects in a complex scene. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Attribute binding is a critical compositionality challenge (Ramesh et al., 2022; Saharia et al., 2022) to existing large-scale diffusion-based models. Despite the improvements in generating multiple objects in the same scene, existing models still fail when given a prompt such as “a brown bench in front of a white building” (see Fig. 1). The output images contains “a white bench” and “a brown building” instead, potentially due to strong training set bias or imprecise language understanding. From a practical perspective, explaining and solving such a two-object binding challenge is a primary step to understanding more complex prompts with multiple objects. Therefore, how to bind the attributes to the correct objects is a fundamental problem for a more complicated and reliable compositional generation. While previous work has addressed compositional T2I (Park et al., 2021), our work tackles open-domain foreground objects with counterfactual attributes, such as color and materials. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/b61a2adf2a0c4ffb5419a27d01d3d821224796a6f7589f156e3de323e338125e.jpg",
+        "image_caption": [
+            "Figure 1: Three challenging phenomena in the compositional generation. Attribute leakage: The attribute of one object is (partially) observable in another object. Interchanged attributes: the attributes of two or more objects are interchanged. Missing objects: one or more objects are missing. With slight abuse of attribute binding definitions, we aim to address all three problems in this work. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            103,
+            782,
+            335
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            434,
+            825,
+            476
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Even though state-of-the-art (SOTA) T2I models are trained on large-scale text-image datasets, they can still suffer from inaccurate results for simple prompts similar to the example above. Hence, we are motivated to seek an alternative, data-efficient method to improve the compositionality. We observe that the attribute-object relation pairs can be obtained as text spans for free from the parsing tree of the sentence. Therefore, we propose to combine the structured representations of prompts, such as a constituency tree or a scene graph, with the diffusion guidance process. Text spans only depict limited regions of the whole image. Conventionally, we need spatial information such as coordinates (Yang et al., 2022) as input to map their semantics into corresponding images. However, coordinate inputs cannot be interpreted by T2I models. Instead, we make use of the observations that attention maps provide free token-region associations in trained T2I models (Hertz et al., 2022). By modifying the key-value pairs in cross-attention layers, we manage to map the encoding of each text span into attended regions in 2D image space. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            650
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we discover similar observations in Stable Diffusion (Rombach et al., 2022) and utilize the property to build structured cross-attention guidance. Specifically, we use language parsers to obtain hierarchical structures from the prompts. We extract text spans across all levels, including visual concepts or entities, and encode them separately to disentangle the attribute-object pairs from each other. Compared to using a single sequence of text embedding for guidance, we improve the compositionality by multiple sequences where each emphasizes an entity or a union of entities from multiple hierarchies in the structured language representations. We refer to our method as Structured Diffusion Guidance (StructureDiffusion). Our contributions can be summarized as three-fold: ",
+        "bbox": [
+            174,
+            656,
+            825,
+            767
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose an intuitive and effective method to improve compositional text-to-image synthesis by utilizing structured representations of language inputs. Our method is efficient and training-free that requires no additional training samples.   \n• Experimental results show that our method achieves more accurate attribute binding and compositionality in the generated images. We also propose a benchmark named Attribute Binding Contrast set (ABC-6K) to measure the compositional skills of T2I models.   \n• We conduct extensive experiments and analysis to identify the causes of incorrect attribute binding, which points out future directions in improving the faithfulness and compositionality of text-to-image synthesis. ",
+        "bbox": [
+            217,
+            782,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/09bca81db2a15f234e6b30d656ac74ab6f9b1cbc101365fd59e52c1916f786df.jpg",
+        "image_caption": [
+            "Figure 2: An illustration of cross-attention operations and the token-region associations from attention maps. We omit some tokens for simplicity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            821,
+            304
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 DIFFUSION MODELS & STRUCTURED GUIDANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            372,
+            612,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose a simple yet effective approach incorporating structured language representations into the cross-attention layers. We briefly introduce the Stable Diffusion model and its critical components in Sec. 2.1. Then, we present our method in detail in Sec. 2.2. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            446
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            465,
+            315,
+            481
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Stable Diffusion We implement our approach and experiments on the state-of-the-art T2I model, Stable Diffusion (Rombach et al., 2022). It is a two-stage method that consists of an autoencoder and a diffusion model. The pre-trained autoencoder encodes images as lower-resolution latent maps for diffusion training. During inference, it decodes generated outputs from the diffusion model into images. The diffusion model generates lower-resolution latent maps based on a random Gaussian noise input $z ^ { T }$ . Given $z ^ { T }$ , it outputs a noise estimation $\\epsilon$ at each step $t$ and subtracts it from $z ^ { t }$ . The final noise-free latent map prediction $z ^ { 0 }$ is fed into the autoencoder to generate images. Stable Diffusion adopts a modified UNet (Ronneberger et al., 2015) for noise estimation and a frozen CLIP text encoder (Radford et al., 2021) to encode text inputs as embedding sequences. The interactions between the image space and the textual embeddings are achieved through multiple cross-attention layers in both downsampling and upsampling blocks. ",
+        "bbox": [
+            173,
+            492,
+            826,
+            647
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CLIP Text Encoder Given an input prompt $\\mathcal { P }$ , the CLIP encoder encodes it as a sequence of embeddings ${ \\mathcal { W } } _ { \\mathrm { p } } = \\mathbf { C } \\mathbf { L I P } _ { \\mathrm { t e x t } } ( \\mathcal { P } )$ where $c _ { \\mathrm { p } }$ is the embedding dimension and $l$ is the sequence length. Our key observation is that the contextualization of CLIP embeddings is a potential cause of incorrect attribute binding. Due to the causal attention masks, tokens in the later part of a sequence are blended with the token semantics before them. For example, When the user indicates some rare color for the second object (e.g. “a yellow apple and red bananas”), Stable Diffusion tends to generate “banana” in “yellow”, as the embeddings of “yellow” is attended by token “banana”. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Cross Attention Layers The cross-attention layers take the embedding sequences from the CLIP text encoder and fuse them with latent feature maps to achieve classifier-free guidance. Denote a 2D feature map $\\mathcal { X } ^ { t }$ , it is projected into queries by a linear layer $f _ { Q } ( \\cdot )$ and reshaped as $Q ^ { t } \\in R ^ { ( n , h \\times w , d ) }$ where $n$ denotes the number of attention heads, $d$ is the feature dimension. Similarly ${ \\mathcal W } _ { \\mathfrak p }$ is projected as keys and values $K _ { \\mathfrak { p } } , V _ { \\mathfrak { p } } \\in R ^ { ( n , l , d ) }$ by linear layers $f _ { K } ( \\cdot ) , f _ { V } ( \\cdot )$ . The attention maps refer to the product between queries and keys, denoted as a function $f _ { M } ( \\cdot )$ ",
+        "bbox": [
+            174,
+            779,
+            825,
+            867
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbad0639bef74ec13696b28a5736eed0f1d8fbb8ce1193600a40bbca688f7a5c.jpg",
+        "text": "$$\nM ^ { t } = f _ { M } ( Q ^ { t } , K _ { p } ) = \\mathrm { S o f t m a x } ( \\frac { Q ^ { t } K _ { \\mathrm { p } } ^ { T } } { \\sqrt { d } } ) , M ^ { t } \\in R ^ { ( n , h \\times w , l ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            875,
+            699,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4f20aec4802f8a65ee210c0541bcc6905c7389daea131d1a009bc1e10573207.jpg",
+        "image_caption": [
+            "Figure 3: An illustration of our cross-attention design with structured representations. We unflatten the query and attention maps and omit the feature dimension $d$ of all query, key, and value tensors for demonstration purposes. Note that noun phrases at multiple hierarchies are extracted and encoded through the frozen CLIP text encoder and projected to value vectors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            102,
+            808,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Cross Attention Controls Hertz et al. (2022) observes that the spatial layouts depend on the cross attention maps in Imagen Saharia et al. (2022). These maps control the layout and structure of generated images, while the values contain rich semantics mapped into attended regions. Therefore, we assume that the image layout and content can be disentangled by controlling attention maps and values separately. ",
+        "bbox": [
+            174,
+            420,
+            826,
+            491
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 STRUCTURED DIFFUSION GUIDANCE ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            507,
+            470,
+            521
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the challenging prompts in Fig. 1, the attribute-object pairs are available for free1 in many structured representations, such as a constituency tree or a scene graph. We seek an implicit way of combining language structures with the cross-attention layers. As is shown in Fig. 3, we can extract multiple noun phrases (NPs) and map their semantics into corresponding regions. Since $M _ { t }$ provides natural token-region associations (see Fig. 2), we can apply it to multiple values from different NPs to achieve region-wise semantic guidance. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            617
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Specifically, given a parser $\\xi ( \\cdot )$ , we first extract a collection of concepts from all hierarchical levels as $\\mathcal { C } = \\{ c _ { 1 } , c _ { 2 } , \\ldots , c _ { k } \\}$ . For constituency parsing, we extract all NPs from the tree structure (see Fig.3 left). For the scene graphs, we extract objects and their relations with another object as text segments. We encode each NP separately: ",
+        "bbox": [
+            173,
+            623,
+            825,
+            680
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/77e28f45441ca9a1d8d56a707d6bdaa8b7e1df8613b506bd80d75eaef538a6af.jpg",
+        "text": "$$\n\\mathbb { W } = [ \\mathcal { W } _ { \\mathrm { p } } , \\mathcal { W } _ { 1 } , \\mathcal { W } _ { 2 } , \\ldots , \\mathcal { W } _ { k } ] , \\mathcal { W } _ { i } = \\mathbf { C } \\mathbf { L } \\mathbf { I } \\mathbf { P } _ { \\mathrm { t e x t } } ( c _ { i } ) , i = 1 , \\ldots k .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            688,
+            707,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The embedding sequence $\\mathcal { W } _ { i }$ is realigned with $\\mathcal { W } _ { p }$ as shown in the middle of Fig. 3. Embeddings between $\\left. \\mathbf { b o s } \\right.$ and $\\langle \\mathrm { p a d } \\rangle$ are inserted into $\\mathcal { W } _ { p }$ to create a new sequence, denoted as $\\overline { { \\mathcal { W } } } _ { i }$ . We use $\\overline { { \\mathcal { W } } } _ { \\mathrm { p } }$ to obtain $K _ { \\mathfrak { p } }$ and $M ^ { t }$ as in Eq. 1, assuming that the full-prompt key is able to generate layouts without missing objects. We obtain a set of values from $\\mathbb { W }$ and multiply each with ${ \\bf { \\bar { \\boldsymbol { M } } } } ^ { t }$ to achieve a conjunction of $k$ NPs in $\\mathcal { C }$ : ",
+        "bbox": [
+            174,
+            714,
+            825,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43cd8d33fb320be7e98c97b79b3bb75f8831ac171d3a50931c712f437aabe5e4.jpg",
+        "text": "$$\n\\begin{array} { c } { \\mathbb { V } = [ f _ { V } ( \\mathcal { W } _ { \\mathrm { p } } ) , f _ { V } ( \\overline { { \\mathcal { W } } } _ { 1 } ) , \\ldots , f _ { V } ( \\overline { { \\mathcal { W } } } _ { k } ) ] = [ V _ { \\mathrm { p } } , V _ { 1 } , \\ldots , V _ { k } ] . } \\\\ { O ^ { t } = \\displaystyle \\frac { 1 } { ( k + 1 ) } \\sum _ { i } ( M ^ { t } V _ { i } ) , i = \\mathrm { p } , 1 , 2 , \\ldots , k . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            795,
+            692,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Compared to using $f _ { V } ( \\mathscr { W } _ { p } )$ only, Eq. 4 does not modify the image layout or composition since $M ^ { t }$ is still calculated from $Q ^ { t } , K _ { p }$ . Empirically, we justify the claim by a series of visualizations of $M _ { t }$ ",
+        "bbox": [
+            174,
+            869,
+            821,
+            898
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 StructureDiffusion Guidance. ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            103,
+            455,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Require: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            123,
+            236,
+            137
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input: Prompt $\\mathcal { P }$ , Parser $\\xi$ , decoder $\\psi$ , trained diffusion model $\\phi$ .   \nOutput: Generated image $x$ .   \n1: Retrieve concept set ${ \\mathcal { C } } = [ c _ { 1 } , \\ldots , c _ { k } ]$ by traversing $\\xi ( \\mathcal { P } )$ ;   \n2: $\\mathcal { W } _ { \\mathrm { p } }  \\mathrm { C L I P } _ { \\mathrm { t e x t } } ( \\mathcal { P } ) .$ , ${ \\mathcal { W } } _ { i } \\gets \\mathbf { C } \\mathbf { L I P _ { \\mathrm { t e x t } } } ( c _ { i } )$ ; $i = 1 , \\ldots , k$   \n3: for $t = T , T - 1 , \\dots , 1$ do   \n4: for each cross attention layer in $\\phi$ do   \n5: Obtain previous layer’s output $\\mathcal { X } ^ { t }$ .   \n6: $Q ^ { t } \\gets \\hat { f } _ { Q } ( \\mathcal { X } ^ { t } ) , \\ \\dot { K _ { \\mathrm { p } } } \\gets \\boldsymbol { f } _ { K } \\mathsf { \\bar { ( } } \\mathcal { W _ { \\mathrm { p } } ) } , \\ V _ { i } \\gets f _ { V } ( \\overline { { \\mathcal { W } } } _ { i } ) ;$ $\\begin{array} { r } { i = { \\tt p } , 1 , \\ldots , k } \\\\ { \\{ { \\tt E q . ~ } 1 \\} } \\\\ { \\{ { \\tt E q . ~ } 4 \\} } \\end{array}$   \n7: Obtain attention maps $M ^ { t }$ from $Q ^ { t } , K _ { \\mathrm { p } }$ ;   \n8: Obtain $O ^ { t }$ from $M ^ { t }$ , $\\{ V _ { i } \\}$ , and feed to following layers;   \n9: end for   \n10: end for   \n11: Feed $z ^ { 0 }$ to decoder $\\psi ( \\cdot )$ to generate $\\mathbf { X }$ . ",
+        "bbox": [
+            178,
+            135,
+            825,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(see Appendix C). However, Stable Diffusion tends to omit objects in generated images (Fig. 1), especially for concept conjunctions that connect two objects with the word “and”. We devise a variant of our method that computes a set of attention maps $\\ddot { \\mathbb { M } } = \\{ M _ { p } ^ { t } , M _ { 1 } ^ { t } , \\dots \\}$ from $\\mathcal { C }$ and multiply them to $\\mathbb { V }$ : ",
+        "bbox": [
+            176,
+            345,
+            825,
+            400
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c767994a3fda118a2d6ccea8934090e68fe5e616eaa672a127b710fa13a54a98.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\mathbb { K } = \\{ f _ { K } ( \\mathcal { W } _ { i } ) \\} , \\mathbb { M } ^ { t } = \\{ f _ { M } ( Q ^ { t } , K _ { i } ) \\} , i = \\mathrm { p } , 1 , 2 , \\ldots , k . } } \\\\ { { O ^ { t } = \\displaystyle \\frac { 1 } { ( k + 1 ) } \\sum _ { i } ( M _ { i } ^ { t } V _ { k } ) , i = \\mathrm { p } , 1 , 2 , \\ldots , k . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            398,
+            694,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "$O ^ { t }$ is the output of a certain cross-attention layer and the input into downstream layers to generate final image $x$ . Our algorithm can be summarized as 1, which requires no training or additional data. ",
+        "bbox": [
+            174,
+            455,
+            823,
+            484
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            503,
+            316,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXPERIMENT SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            534,
+            382,
+            549
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets To address attribute binding and compositional generation, we propose a new benchmark, Attribute Binding Contrast set (ABC-6K). It consists of natural prompts from MSCOCO where each contains at least two color words modifying different objects. We also switch the position of two color words to create a contrast caption (Gardner et al., 2020). We end up with $6 . 4 \\mathrm { K }$ captions or 3.2K contrastive pairs. In addition to natural compositional prompts, we challenge our method with less detailed prompts that conjunct two concepts together. These prompts follow the sentence pattern of “a red apple and a yellow banana” and conjunct two objects with their attribute descriptions. We refer to this set of prompts as Concept Conjunction 500 (CC-500). We also evaluate our method on 10K randomly sampled captions from MSCOCO (Lin et al., 2014). We show that our method generalizes beyond attribute binding and introduces no quality degradation for general prompts. ",
+        "bbox": [
+            173,
+            560,
+            825,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metrics We mainly rely on human evaluations for compositional prompts and concept conjunction (ABC-6K & CC-500). We ask annotators to compare two generated images, from Stable Diffusion and our method respectively, and indicate which image demonstrates better image-text alignment or image fidelity. For image fidelity, we ask the annotators “Regardless of the text, which image is more realistic and natural?”. We also investigate an automatic evaluation metric for image compositions, i.e., using a SOTA phrase grounding model GLIP (Li et al., 2022) to match phraseobject pairs. As for system-level evaluation, we follow previous work to utilize Inception Score (IS) (Salimans et al., 2016), Frechet Inception Distance (FID) (Heusel et al., 2017) and CLIP R-precision ´ (R-prec.) (Park et al., 2021). IS and FID mainly measure the image bank’s systematic quality and diversity, while R-prec measures image-level alignment. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 COMPOSITIONAL PROMPTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            403,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here we show the quantitative and qualitative evaluation results on ABC-6K. We observe that our method sometimes generates very similar images to Stable Diffusion. Hence, we first generate two images per prompt for our method and Stable Diffusion, involving around 12K image pairs to compare. Then, we filter out $20 \\%$ of the most similar pairs and then randomly sampled 1500 pairs for human evaluations. As shown in Table 1, annotators indicate around a $42 \\%$ chance of our method winning the comparison, $7 \\%$ higher than losing the comparison. There is still a $22 \\%$ of chance that our images are tied with images from Stable Diffusion. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/86f2f5b3874d91915911d0f79b795f8140a36efe891911187b5ee1b649a4af98.jpg",
+        "table_caption": [
+            "Table 1: Percentage of generated images of StructureDiffusion that are better than (win), tied with, or worse than (lose) the compared model in terms of text-image alignment and image fidelity. We filtered out $20 \\%$ most similar image pairs for comparison (See Sec. E). Composable Diffusion cannot be applied to ABC-6K as those prompts may not contain explicit “and” words that separate concepts. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Benchmark</td><td rowspan=\"2\">StructureDiffusion (ours) v.s.</td><td colspan=\"3\">Alignment</td><td colspan=\"3\">Fidelity</td></tr><tr><td>Win (↑)</td><td>Lose (↓)</td><td>Tie</td><td>Win (↑)</td><td>Lose (↓)</td><td>Tie</td></tr><tr><td>ABC-6K</td><td>Stable Diffusion</td><td>42.2</td><td>35.6</td><td>22.2</td><td>48.3</td><td>39.1</td><td>12.6</td></tr><tr><td rowspan=\"2\">CC-500</td><td>Stable Diffusion</td><td>31.8</td><td>27.7</td><td>38.9</td><td>37.8</td><td>30.6</td><td>31.6</td></tr><tr><td>Composable Diffusion</td><td>46.5</td><td>30.1</td><td>22.8</td><td>61.4</td><td>19.8</td><td>18.8</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            821,
+            195
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cde95ccdebc9693de8c741688cd3b4fadc9ef5c3215551ed35f2b60c361cda4c.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative results on ABC-6K. Our method improves both object-level and scene-level compositionality. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            284,
+            805,
+            523
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            599,
+            825,
+            669
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We show qualitative examples characterizing three different perspectives in Fig. 4. Our method fills in the correct color for different parts of an object or different objects, as shown in the first two examples. The third example demonstrates that our method can mitigate the issue of “missing objects”. Among the $42 \\%$ winning cases, there are $31 \\%$ for “fewer missing objects”, $1 4 . 1 \\%$ for “better-matched colors”, and $5 4 . 8 \\%$ for “other attributes or details” as indicated by annotators. The results certify that the improvement goes beyond colors to component completeness and fine-grained details. More qualitative examples characterizing all three aspects can be found in Fig. 14 in the Appendix. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 CONCEPT CONJUNCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            810,
+            388,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we address challenging concept conjunction prompts and evaluate our method on CC-500. Apart from Stable Diffusion, we also compare to Composable Diffusion (Liu et al., 2022) implemented on top of Stable Diffusion. For Composable Diffusion, we separate the prompts into text segments by the keyword “and” and feed each span into an independent diffusion process. We generate three images per prompt and use all images for human evaluation for Stable Diffusion. We randomly sampled 600 images for comparison to Composable Diffusion. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/825a83d0f632061daf6fb88e161b5e3156d0b285af107e2b19768aef342833ae.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"6\">CC-500 (Prompt format: “a [colorA] [objectA] and a [colorB] [objectB]&quot;)</td></tr><tr><td></td><td>Human Annotations</td><td></td><td>GLIP</td><td></td><td>Human-GLIP</td></tr><tr><td>Methods</td><td>Zero/One obj. ()</td><td>Two obj.</td><td>Two obj. w/ correct colors</td><td>Zero/One obj.(↓)</td><td>Two obj.</td><td>Consistency</td></tr><tr><td>Stable Diffusion</td><td>65.5</td><td>34.5</td><td>19.2</td><td>69.0</td><td>31.0</td><td>46.4</td></tr><tr><td>Composable Diffusion</td><td>69.7</td><td>30.3</td><td>20.6</td><td>74.2</td><td>25.8</td><td>48.9</td></tr><tr><td>StructureDiffusion (Ours)</td><td>62.0</td><td>38.0</td><td>22.7</td><td>68.8</td><td>31.2</td><td>47.6</td></tr></table>",
+        "bbox": [
+            171,
+            101,
+            820,
+            222
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Fine-grained human and automatic evaluation results on CC-500. Recall that each prompt is a conjunction of two different objects with different colors. “Zero/One obj.” means that the model fails to generate all desired objects in the image. “Human-GLIP consistency” reflects the percentage of images where human annotations align with GLIP detection results. ",
+        "bbox": [
+            173,
+            232,
+            825,
+            287
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3902d5a9c111e4d4a12e67c65e27de1a9c2c07d74efa1fca4dfa19aefa3dbcb9.jpg",
+        "image_caption": [
+            "Figure 5: Qualitative results on CC-500 prompts that emphasize two aspects. (a) Color leakage: our method prevents the green color from invading the bird or apple. (b) Missing objects: our method completes the “blue bowl” and improves the quality of the “blue apple”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            303,
+            802,
+            537
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1, our method outperforms Stable Diffusion by around $4 . 1 \\%$ and Composable Diffusion by $1 6 . 4 \\%$ in terms of image-text alignment. We also observe that our method enhances some fine-grained details in the generated images, leading to a $7 . 2 \\%$ improvement in image fidelity when compared with Stable Diffusion. We observe that images from composable diffusion can be oversaturated with unnatural visual textures and layouts, which could be the reason for StructureDiffusion to have high win rate in image fidelity. As shown in Fig. 5 and Fig. 13. Our approach prevents color bleeding (left), missing objects (right) and strengthens details (right). ",
+        "bbox": [
+            174,
+            622,
+            825,
+            720
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To further quantify the text-image alignment, we consider both human annotations and automatic evaluations. For each object mentioned in the prompt, we ask annotators whether the object exists in the image and whether it is in the correct color. We also apply a state-of-the-art detection model GLIP (Li et al., 2022) to ground each “a [color] [object]” phrase into bounding boxes. We report the percentage of images that contain incomplete objects / complete objects / complete objects with correct colors in Table 2. StructureDiffusion improves the compositionality by $3 . 5 \\%$ based on human annotations while only $0 . 2 \\%$ based on GLIP. We discover that humans disagree with GLIP for more than $50 \\%$ of the images, as entailed by the low consistency rate. Previous work also suggests the deficiency of large pre-trained models in compositional understanding (Thrush et al., 2022). ",
+        "bbox": [
+            174,
+            727,
+            825,
+            853
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 OTHER PROMPTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            333,
+            883
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We show that our StructureDiffusion maintain the overall image quality and diversity on general prompts. We follow the standard evaluation process and generate 10,000 images from randomly ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e0cc7567ff201cd421e0f017febca9fe7cd7bc251c12c2c41f6a6f273c0b81cb.jpg",
+        "image_caption": [
+            "Figure 6: Qualitative results of using scene graph parser to generate structured representations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            821,
+            198
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7dfce557e99a420d3ccd8d1cf8e3979db4bd6ad9b3761a1fd404947bf41071bb.jpg",
+        "image_caption": [
+            "Figure 7: Ablation study on the text sequence embeddings. We find that the padding embeddings are fully contextualized, representing the prompt’s high-level semantics. However, not all padding tokens are necessary to maintain a high-fidelity output from Stable Diffusion. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            244,
+            802,
+            429
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "sampled MSCOCO captions. Stable Diffusion obtains 39.9 IS, 18.0 FID and 72.2 R-Precision. Our method achieves 40.9 IS, 17.9 FID and $7 2 . 3 \\mathrm { R }$ -Precision. StructureDiffusion maintains the image fidelity and diversity as indicated in the comparable IS/FID/R-Prec scores. ",
+        "bbox": [
+            176,
+            513,
+            825,
+            555
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.5 SCENE GRAPH INPUT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            577,
+            362,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We show that our method is not limited to constituency parsing but can also be extended to other structured representations, such as scene graphs. As shown in Fig. 6, we first adopt the scene graph parser (Wu et al., 2019) and obtain a graph like the ones next to each image from the input prompt. The parser returns basic entities and their relations in between. We extract text spans of basic entities with their attributes attached and text spans that include two related entities. We provide examples in Appendix 3 and make comparison to the constituency parser. Similarly, we encode these spans separately and re-align each with the entire prompt encoding sequence. On MS-COCO, the scene graph parser setting maintains the image quality with 39.2 IS, 17.9 FID, and 72.0 R-Precision. When compared to Stable Diffusion on ABC-6K, the scene graph parser achieves $3 4 . 2 \\% - 3 2 . 9 \\% - 3 2 . 9 \\%$ Win-Lose-Tie in image-text alignment and $3 4 . 5 \\% - 3 2 . 5 \\% - 3 3 . 0 \\%$ Win-Lose-Tie in image fidelity. As for CC-500, the scene graph parser leads to the same output images due to the same text spans. We refer to Table 3 and Fig. 12 for more results and comparison. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            770
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            356,
+            809
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 RE-ALIGNING SEQUENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            392,
+            840
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Section 2, we describe a method to realign the encoding of a text span back into the sequence of the full prompt. Since the noun-phrase text spans are shorter than the full sequence, re-alignment ensures that each token’s value vector corresponds to the correct attention map. On the other hand, naively expanding the span to the length of the full sequence degrades the image quality by ${ \\sim } 2 \\mathrm { I S } /$ FID (37.5 IS, 19.8 FID) compared to images with re-alignment or Stable Diffusion. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 CONTEXTUALIZED TEXT EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            486,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One limitation brought by our StructureDiffusion is that the cross-attention computation costs increase by the number of noun phrases. Yet we noticed that most of the attention maps are computed from padding embeddings, as Stable Diffusion adopts CLIP text encoders and automatically pads the sequence to 77 tokens. We conjecture that not all padding tokens are necessary for generating high-quality images. As is shown in Fig. 7, we study four different patterns of token embeddings. We discover that leaving the nearest padding embeddings maintains a similar IS / FID score as the full sequence. Further removing this padding embedding results in apparent degradation. While only using the nearest padding embedding results in the worst image quality, we find that the high-level image layout and semantics are preserved (see bottom right of Fig. 7). This phenomenon indicates that the padding embeddings are fully contextualized with the full prompt semantics. This also justifies our re-alignment operation that preserves padding embeddings of the main sequence ${ \\mathcal { W } } _ { \\mathrm { f u l l } }$ . ",
+        "bbox": [
+            174,
+            131,
+            825,
+            284
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            308,
+            344,
+            324
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Text-to-Image Synthesis The diffusion model is an emerging type of model that generate highquality images with a much more stable training process (Song & Ermon, 2019; Ho et al., 2020). Rombach et al. (2022) proposes to encode an image with an autoencoder and then leverage a diffusion model to generate continuous feature maps in the latent space. Stable Diffusion Rombach et al. (2022) adopts similar architecture but is trained on large-scale image-text datasets with fixed CLIP text encoder. Imagen (Saharia et al., 2022) addresses the importance of language understanding by using a frozen T5 encoder (Raffel et al., 2020), a dedicated large language model. We mainly focus on diffusion models and conduct our experiments on Stable Diffusion (Rombach et al., 2022), the SOTA open-sourced T2I model. ",
+        "bbox": [
+            174,
+            340,
+            826,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Compositional Generation The compositional or controllable generation has been an essential direction for T2I models to understand and disentangle basic concepts in the generation process. As text inputs are relatively weak conditions, previous work leverage layout or scene graph to enhance compositionality (Johnson et al., 2018; Hong et al., 2018; Yang et al., 2022; Gafni et al., 2022). More recently, Liu et al. (2022) proposes an approach where the concept conjunctions are achieved by adding estimated scores from a parallel set of diffusion processes. In contrast, our method can be directly merged into the cross-attention layers with much less computational overhead. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            583
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diffusion Guidance Ho & Salimans (2022) develops classifier-free guidance where a single diffusion model is jointly trained under conditional and unconditional inputs. Most large-scale SOTA models, including autoregressive ones, adopt this technique for flexible and improved conditional synthesis results (Rombach et al., 2022; Ramesh et al., 2022; Gafni et al., 2022; Yu et al., 2022; Saharia et al., 2022). Hertz et al. (2022) discovers unique properties of cross attention maps on Imagen (Saharia et al., 2022) and achieves structure-preserving image editing by manipulating these maps. We observe similar properties in Stable Diffusion (Rombach et al., 2022) but propose a different algorithm for fine-grained, compositional text-to-image generation. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            737,
+            318,
+            753
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a training-free method for compositional text-to-image generation. First, we observe that existing large-scale T2I diffusion models can still struggle in compositional image synthesis. We address this challenge by explicitly focusing on binding objects with the correct attributes. Second, we propose structured diffusion guidance incorporating language structures into the cross-attention layers. We propose two simple techniques to align the structured encoding with the attention maps. Using our structured guidance on Stable Diffusion, attributes can be bound more accurately while maintaining the overall image quality and diversity. In addition, we justify our approach by conducting an in-depth analysis of the frozen language encoder and attention maps. Future work may explore explicit approaches to generate plausible image layouts without missing components. We hope that our approach accelerates the development of interpretable and efficient methods for diffusion-based text-to-image models. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            357,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank the Robert N. Noyce Trust for their generous gift to the University of California via the Noyce Initiative. The work was also partially funded by an unrestricted gift from Google and by the National Science Foundation award #2048122. The writers’ opinions and conclusions in this publication are their own and should not be construed as representing the sponsors’ official policy, expressed or inferred. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REPRODUCIBILITY STATEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            224,
+            437,
+            241
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We release our core codebase containing the methodology implementation, settings, benchmarks containing compositional prompts under supplementary materials. ",
+        "bbox": [
+            174,
+            256,
+            823,
+            285
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ETHICAL STATEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            305,
+            356,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As for the data collection and verification, we use the Amazon Mechanical Turk platform and form the comparison task as batches of HITs. We select workers from English-speaking countries, including the US, CA, UK, AU, and NZ, since the task require understanding the English input prompt. Each HIT takes around 15-30 seconds on average to accomplish, and we pay each submitted HIT with 0.15 US dollars, resulting in an hourly payment of 18 US dollars. ",
+        "bbox": [
+            174,
+            337,
+            825,
+            406
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            429,
+            285,
+            444
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prafulla Dhariwal and Alexander Nichol. Diffusion models beat gans on image synthesis. Advances in Neural Information Processing Systems, 34:8780–8794, 2021. ",
+        "bbox": [
+            173,
+            452,
+            823,
+            481
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ming Ding, Wendi Zheng, Wenyi Hong, and Jie Tang. Cogview2: Faster and better text-to-image generation via hierarchical transformers. arXiv preprint arXiv:2204.14217, 2022. ",
+        "bbox": [
+            171,
+            489,
+            823,
+            518
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alaaeldin El-Nouby, Shikhar Sharma, Hannes Schulz, Devon Hjelm, Layla El Asri, Samira Ebrahimi Kahou, Yoshua Bengio, and Graham W.Taylor. Tell, Draw, and Repeat: Generating and Modifying Images Based on Continual Linguistic Instruction. In ICCV, 2019. ",
+        "bbox": [
+            176,
+            529,
+            823,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tsu-Jui Fu, Xin Eric Wang, Scott Grafton, Miguel Eckstein, and William Yang Wang. SSCR: Iterative Language-Based Image Editing via Self-Supervised Counterfactual Reasoning. In EMNLP, 2020. ",
+        "bbox": [
+            171,
+            580,
+            825,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oran Gafni, Adam Polyak, Oron Ashual, Shelly Sheynin, Devi Parikh, and Yaniv Taigman. Make-ascene: Scene-based text-to-image generation with human priors. arXiv preprint arXiv:2203.13131, 2022. ",
+        "bbox": [
+            174,
+            619,
+            826,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matt Gardner, Yoav Artzi, Victoria Basmov, Jonathan Berant, Ben Bogin, Sihao Chen, Pradeep Dasigi, Dheeru Dua, Yanai Elazar, Ananth Gottumukkala, et al. Evaluating models’ local decision boundaries via contrast sets. Findings of Empirical Methods in Natural Language Processing, 2020. ",
+        "bbox": [
+            173,
+            671,
+            826,
+            727
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuyang Gu, Dong Chen, Jianmin Bao, Fang Wen, Bo Zhang, Dongdong Chen, Lu Yuan, and Baining Guo. Vector quantized diffusion model for text-to-image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10696–10706, 2022a. ",
+        "bbox": [
+            174,
+            738,
+            826,
+            780
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shuyang Gu, Dong Chen, Jianmin Bao, Fang Wen, Bo Zhang, Dongdong Chen, Lu Yuan, and Baining Guo. Vector quantized diffusion model for text-to-image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10696–10706, 2022b. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Amir Hertz, Ron Mokady, Jay Tenenbaum, Kfir Aberman, Yael Pritch, and Daniel Cohen-Or. Promptto-prompt image editing with cross attention control. arXiv preprint arXiv:2208.01626, 2022. ",
+        "bbox": [
+            171,
+            843,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural information processing systems, 30, 2017. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ho and Tim Salimans. Classifier-free diffusion guidance. arXiv preprint arXiv:2207.12598, 2022. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in Neural Information Processing Systems, 33:6840–6851, 2020. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            169
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Seunghoon Hong, Dingdong Yang, Jongwook Choi, and Honglak Lee. Inferring semantic layout for hierarchical text-to-image synthesis. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 7986–7994, 2018. ",
+        "bbox": [
+            176,
+            176,
+            823,
+            219
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Agrim Gupta, and Li Fei-Fei. Image generation from scene graphs. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1219–1228, 2018. ",
+        "bbox": [
+            171,
+            227,
+            823,
+            256
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Doyup Lee, Chiheon Kim, Saehoon Kim, Minsu Cho, and Wook-Shin Han. Autoregressive image generation using residual quantization. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 11523–11532, 2022. ",
+        "bbox": [
+            174,
+            262,
+            823,
+            306
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bowen Li, Xiaojuan Qi, Thomas Lukasiewicz, and Philip Torr. Controllable text-to-image generation. Advances in Neural Information Processing Systems, 32, 2019. ",
+        "bbox": [
+            173,
+            313,
+            825,
+            343
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Liunian Harold Li, Pengchuan Zhang, Haotian Zhang, Jianwei Yang, Chunyuan Li, Yiwu Zhong, Lijuan Wang, Lu Yuan, Lei Zhang, Jenq-Neng Hwang, et al. Grounded language-image pre-training. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10965–10975, 2022. ",
+        "bbox": [
+            173,
+            349,
+            826,
+            406
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollar, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ´ European conference on computer vision, pp. 740–755. Springer, 2014. ",
+        "bbox": [
+            176,
+            414,
+            825,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luping Liu, Yi Ren, Zhijie Lin, and Zhou Zhao. Pseudo numerical methods for diffusion models on manifolds. In International Conference on Learning Representations, 2021a. ",
+        "bbox": [
+            169,
+            464,
+            823,
+            494
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nan Liu, Shuang Li, Yilun Du, Antonio Torralba, and Joshua B Tenenbaum. Compositional visual generation with composable diffusion models. arXiv preprint arXiv:2206.01714, 2022. ",
+        "bbox": [
+            171,
+            501,
+            823,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xihui Liu, Dong Huk Park, Samaneh Azadi, Gong Zhang, Arman Chopikyan, Yuxiao Hu, Humphrey Shi, Anna Rohrbach, and Trevor Darrell. More control for free! image synthesis with semantic diffusion guidance. arXiv preprint arXiv:2112.05744, 2021b. ",
+        "bbox": [
+            176,
+            537,
+            823,
+            580
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chao Lou, Wenjuan Han, Yuhuan Lin, and Zilong Zheng. Unsupervised vision-language parsing: Seamlessly bridging visual scene graphs with language structures via dependency relationships. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pp. 15607–15616, June 2022. ",
+        "bbox": [
+            174,
+            587,
+            826,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Nichol, Prafulla Dhariwal, Aditya Ramesh, Pranav Shyam, Pamela Mishkin, Bob McGrew, Ilya Sutskever, and Mark Chen. Glide: Towards photorealistic image generation and editing with text-guided diffusion models. ICML, 2021. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dong Huk Park, Samaneh Azadi, Xihui Liu, Trevor Darrell, and Anna Rohrbach. Benchmark for compositional text-to-image synthesis. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 1), 2021. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            746
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peng Qi, Yuhao Zhang, Yuhui Zhang, Jason Bolton, and Christopher D. Manning. Stanza: A Python natural language processing toolkit for many human languages. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics: System Demonstrations, 2020. ",
+        "bbox": [
+            174,
+            752,
+            825,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, et al. Learning transferable visual models from natural language supervision. In International Conference on Machine Learning, pp. 8748–8763. PMLR, 2021. ",
+        "bbox": [
+            174,
+            803,
+            826,
+            859
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(140):1–67, 2020. URL http://jmlr.org/papers/v21/20-074.html. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aditya Ramesh, Mikhail Pavlov, Gabriel Goh, Scott Gray, Chelsea Voss, Alec Radford, Mark Chen, and Ilya Sutskever. Zero-shot text-to-image generation. In International Conference on Machine Learning, pp. 8821–8831. PMLR, 2021. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditya Ramesh, Prafulla Dhariwal, Alex Nichol, Casey Chu, and Mark Chen. Hierarchical textconditional image generation with clip latents. arXiv preprint arXiv:2204.06125, 2022. ",
+        "bbox": [
+            171,
+            154,
+            825,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Bjorn Ommer. High- ¨ resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10684–10695, 2022. ",
+        "bbox": [
+            174,
+            190,
+            825,
+            234
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computerassisted intervention, pp. 234–241. Springer, 2015. ",
+        "bbox": [
+            176,
+            242,
+            825,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nataniel Ruiz, Yuanzhen Li, Varun Jampani, Yael Pritch, Michael Rubinstein, and Kfir Aberman. Dreambooth: Fine tuning text-to-image diffusion models for subject-driven generation. arXiv preprint arXiv:2208.12242, 2022. ",
+        "bbox": [
+            176,
+            292,
+            825,
+            335
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chitwan Saharia, William Chan, Saurabh Saxena, Lala Li, Jay Whang, Emily Denton, Seyed Kamyar Seyed Ghasemipour, Burcu Karagol Ayan, S Sara Mahdavi, Rapha Gontijo Lopes, et al. Photorealistic text-to-image diffusion models with deep language understanding. arXiv preprint arXiv:2205.11487, 2022. ",
+        "bbox": [
+            173,
+            343,
+            826,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. Advances in neural information processing systems, 29, 2016. ",
+        "bbox": [
+            174,
+            409,
+            826,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Schuster, Ranjay Krishna, Angel Chang, Li Fei-Fei, and Christopher D Manning. Generating semantically precise scene graphs from textual descriptions for improved image retrieval. In Proceedings of the fourth workshop on vision and language, pp. 70–80, 2015. ",
+        "bbox": [
+            174,
+            459,
+            826,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yang Song and Stefano Ermon. Generative modeling by estimating gradients of the data distribution. Advances in Neural Information Processing Systems, 32, 2019. ",
+        "bbox": [
+            174,
+            511,
+            823,
+            540
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ming Tao, Hao Tang, Fei Wu, Xiao-Yuan Jing, Bing-Kun Bao, and Changsheng Xu. Df-gan: A simple and effective baseline for text-to-image synthesis. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 16515–16525, 2022. ",
+        "bbox": [
+            174,
+            546,
+            826,
+            590
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tristan Thrush, Ryan Jiang, Max Bartolo, Amanpreet Singh, Adina Williams, Douwe Kiela, and Candace Ross. Winoground: Probing vision and language models for visio-linguistic compositionality. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 5238–5248, 2022. ",
+        "bbox": [
+            173,
+            598,
+            826,
+            656
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bo Wan, Wenjuan Han, Zilong Zheng, and Tinne Tuytelaars. Unsupervised vision-language grammar induction with shared structure modeling. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            171,
+            662,
+            823,
+            707
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hao Wu, Jiayuan Mao, Yufeng Zhang, Yuning Jiang, Lei Li, Weiwei Sun, and Wei-Ying Ma. Unified visual-semantic embeddings: Bridging vision and language with structured meaning representations. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6609–6618, 2019. ",
+        "bbox": [
+            173,
+            714,
+            826,
+            770
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zuopeng Yang, Daqing Liu, Chaoyue Wang, Jie Yang, and Dacheng Tao. Modeling image composition for complex scene generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 7764–7773, 2022. ",
+        "bbox": [
+            173,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiahui Yu, Yuanzhong Xu, Jing Yu Koh, Thang Luong, Gunjan Baid, Zirui Wang, Vijay Vasudevan, Alexander Ku, Yinfei Yang, Burcu Karagol Ayan, et al. Scaling autoregressive models for contentrich text-to-image generation. arXiv preprint arXiv:2206.10789, 2022. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Han Zhang, Jing Yu Koh, Jason Baldridge, Honglak Lee, and Yinfei Yang. Cross-modal contrastive learning for text-to-image generation. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 833–842, 2021. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yiwu Zhong, Liwei Wang, Jianshu Chen, Dong Yu, and Yin Li. Comprehensive image captioning via scene graph decomposition. In European Conference on Computer Vision, pp. 211–229. Springer, 2020. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            145
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yufan Zhou, Ruiyi Zhang, Changyou Chen, Chunyuan Li, Chris Tensmeyer, Tong Yu, Jiuxiang Gu, Jinhui Xu, and Tong Sun. Towards language-free training for text-to-image generation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 17907–17917, 2022. ",
+        "bbox": [
+            176,
+            154,
+            826,
+            210
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Minfeng Zhu, Pingbo Pan, Wei Chen, and Yi Yang. Dm-gan: Dynamic memory generative adversarial networks for text-to-image synthesis. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pp. 5802–5810, 2019. ",
+        "bbox": [
+            174,
+            218,
+            825,
+            261
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            348,
+            303
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Text-to-Image Synthesis There are mainly three types of models for text-to-image synthesis: GAN-based (Tao et al., 2022; Zhu et al., 2019; Li et al., 2019; Fu et al., 2020; El-Nouby et al., 2019), autoregressive (Gu et al., 2022b; Lee et al., 2022; Ding et al., 2022) and diffusion models (Liu et al., 2021b; Nichol et al., 2021; Ruiz et al., 2022). Zhang et al. (2021) proposes XMC-GAN, a one-stage GAN that employs multiple contrastive losses between image-image, image-text, and region-token pairs. More recently, LAFITE (Zhou et al., 2022) enables language-free training by constructing pseudo image-text feature pairs using CLIP (Radford et al., 2021). As for autoregressive models, DALL-E adopts VQ-VAE to quantize image patches into tokens and then uses a transformer to generate discrete tokens sequentially (Ramesh et al., 2021). Parti (Yu et al., 2022) and Make-A-Scene (Gafni et al., 2022) both leverage classifier-free guidance to improve controllability. As for diffusion models, Gu et al. (2022a) concatenates VQ-VAE with the diffusion model and shows that the diffusion process can operate in discrete latent space. DALL-E 2 adopts the CLIP text encoder so that the diffusion process inverts the textual features into images (Ramesh et al., 2022). ",
+        "bbox": [
+            174,
+            318,
+            825,
+            497
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Structured Representations for Vision and Language Inferring shared structures across language and vision has been a long-term pursuit in unifying these modalities (Schuster et al., 2015; Johnson et al., 2018; Zhong et al., 2020; Lou et al., 2022). Wu et al. (2019) utilizes the structure from semantic parsing in a visual-semantic embedding framework to facilitate embedding learning. Wan et al. (2021) proposes a new task in which the goal is to learn a joint structure between semantic parsing and image regions. To the best of our knowledge, our work is the first attempt in T2I to incorporate language structures into the image synthesizing process. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            611
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Diffusion Guidance To convert an unconditional diffusion model into a class-conditional one, Dhariwal & Nichol (2021) input the noisy image from each step into a classifier and calculate the classification loss. The loss can be back-propagated to the image space to provide a gradient that marginalizes the score estimation from the log of conditional probability. Similarly, in the T2I subdomain, Liu et al. (2021b) and Nichol et al. (2021) apply a noisy CLIP model to measure the cosine similarity between text prompts and noisy images. ",
+        "bbox": [
+            174,
+            626,
+            825,
+            709
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            729,
+            439,
+            744
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Throughout the experiments, we implement our method upon Stable Diffusion v1.4. For all comparisons between our method and Stable Diffusion, we fix the seed to generate the same initial Gaussian map and use 50 diffusion steps with PLMS sampling (Liu et al., 2021a). We fix the guidance scale to 7.5 and equally weight the key-value matrices in cross-attention layers if not otherwise specified. We do not add hand-crafted prompts such as “a photo of” to the text input. We use the Stanza Library (Qi et al., 2020) for constituency parsing and obtain noun phrases if not otherwise specified. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            844
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C VISUALIZATION OF ATTENTION MAPS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            864,
+            529,
+            880
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate the visualization of cross-attention maps to support our assumptions and claims in Sec. 2. As is shown in Fig. 8, the attention maps of Stable Diffusion and our method have similar spatial distribution and highlights throughout the diffusion process. This phenomenon supports our assumption in Sec. 2.2 that the attention map $M _ { t }$ is unchanged even with multiple values in each cross-attention layer. We can observe a similar phenomenon in Fig. 9 except that our method accelerates the formation of interpretable attentions for both “green” and “clock” tokens. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/e22e2d5e7ace9b5fbcfe4a7cc12e67be8180444f5dc3271034867469bdbfde5a.jpg",
+        "image_caption": [
+            "Figure 8: Visualization of cross attention maps of Stable Diffusion and our method. We compare maps of multiple tokens throughout the whole diffusion process with equal intervals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            103,
+            820,
+            536
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            694,
+            825,
+            750
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Fig. 8, 9 also justify our claim that values represent rich textual semantics mapped to the image space as contents. For instance, our method parses the prompt in Fig. 8 into “A long narrow yellow kitchen” and “black and white floor tiles”, encodes and aligns them separately to form V. Empirically, these operations enhance the semantics of “yellow” and “black and white” separately and mitigate “yellow” being blended into “black and white”. This explains the disappearance of color leakage in our image compared to Stable Diffusion. Though one may attribute the leakage to incorrect attention distribution of the “yellow” token, we argue that this is not the critical reason. Despite the attention maps of “yellow” from our method slightly highlighting the “floor tile” regions, we cannot observe any yellow in our generated image. This proves that inaccurate attention distributions contribute little to the final image content. In addition, we also show in Fig. 10 that using multiple Keys is able to rectify the image layouts to mitigate missing object issues. The sheep-like attention maps in the third row verify the proposed variants of our method for concept conjunctions. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/0be7b80d0f76ab47ff37221209affb8a234d6aaf76276fa61011c736050abb18.jpg",
+        "image_caption": [
+            "Figure 9: Visualization of cross attention maps corresponding to token “green” and “clock” across the full diffusion timestamps from step 50 to step 1 in equal intervals. Red boxes highlight steps where our method accelerates the formation of correct attention on the clock region. The evolution of the token “green” is also more interpretable in our method. Although the image composition is imperfect, the visualization still supports our assumptions and claims in Sec. 2.2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            107,
+            812,
+            325
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ce94909eda492a7e78221376ea5b39def302a7a1f5a92084ca40943ea3a1fda.jpg",
+        "image_caption": [
+            "Figure 10: Visualization of attention maps for token “sheep” of different methods. Our method with multiple Keys successfully rectify image layouts. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            433,
+            821,
+            734
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            806,
+            361,
+            823
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D.1 A CASE STUDY OF ATTRIBUTE BINDING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            491,
+            854
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here, we present a case study to show evidence of two root causes of incorrect attribute binding. The first one is the contextualized token embeddings due to causal attention masks. As is shown on the left side of Fig. 11, we first encode two different prompts with a shared component, e.g. “a red apple” as the naive one and “a green bag and a red apple”. Using the encoding sequence of the naive prompt, we are able to get an image of red apple only. It is reasonable to assume that the yellow green regions are natural results of learning from authentic apple images. Then, we replace the tokens of the naive prompt with embeddings of the same token from the more complicated prompt. We use the same gaussian noise as initialization and generate an unnatural image with a solid green region (in the yellow bounding box). This result proves that the token “red” is contaminated with the semantics of “green” before it and explains some images with color leakage problems (e.g., Fig. 1). ",
+        "bbox": [
+            174,
+            867,
+            826,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/3523608906863534f4a3e158ef3281942b6bb6822477164e5d40472b91acf880.jpg",
+        "image_caption": [
+            "Figure 11: Examples showing the potential root causes of incorrect attribute binding. Left: The large green regions in the second image prove that the hidden state’s output of token “red” is contextualized with token “green” before it. Right: Visualization of attention maps showing that the semantics from the token “bird” is mistakenly attended to the mouth region of the bear. The final image shows the unnatural beak-like shape of the bear. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            103,
+            818,
+            343
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            457,
+            825,
+            541
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The second reason attributes to inaccurate attention maps. In Fig. 11 (right), we visualize five crossattention maps (averaged across attention heads) from both downsample and upsampling blocks. The attention maps show the salient regions corresponding to the token “bird”. These maps demonstrate highlighted regions in the bottom left corner where the bird is located in the final image. Despite the interpretable structures, the maps also show saliency around the mouth region of the bear across all five layers. Thus, the inaccurate attention maps lead to a beak-like mouth of the bear in the image. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            631
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D.2 COMPARISON OF PARSERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            648,
+            401,
+            662
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we compare the difference between using a constituency parser and a scene graph parser to obtain text spans and generate images. Table 3 compares the extracted text spans using constituency parser and scene graph parser. Example 0 shows that both parsers end up with the same results for CC-500 prompts. For Example 1-4, the scene graph parser generates more spans than the constituency parser. We notice that concepts in the middle of the sentence appear more often in these spans than other noun tokens, like “egg” or “red sauce” in Example 3. This imbalance potentially explains why the “egg” looks more highlighted in Fig. 12 (bottom left). On the other hand, “orange slices” appear more often in constituency parsing results, leading to better “orange” textures in the generated image. Similar observations can be made in Example 2, where “green pole” is emphasized more often by the constituency parser. ",
+        "bbox": [
+            174,
+            675,
+            825,
+            815
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E LIMITATIONS & FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            472,
+            852
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "There are several limitations of our work. First of all, our method depends on an external parsing function that may not be perfect. We adopt the commonly used Stanza Library Qi et al. (2020) for constituency parsing. The parsing function can be replaced with a more advanced learning-based method for improvement. Secondly, our method mainly focuses on compositional T2I neglecting any style descriptions. The parsing mechanism may categorize a style description, e.g. “in Van Gogh style” as a separate noun phrase that cannot be grounded in the image space. In addition, we discover that StructureDiffusion tends to generate similar images as Stable Diffusion. Thus we filtered out $20 \\%$ of most similar image pairs in Table 1, considering the efficiency of human evaluation. Therefore, the improvement could be compromised when evaluated on the full set of generated images. Future work may focus on devising explicit methods to associate attributes to objects using spatial information as input. For example, how to make a text-to-image synthesis model interpret coordinate information with limited fine-tuning or prompt tuning steps would be an appealing direction. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/cf2ac2229777fca8ab753b0b0931fc8b755d2babbe943c720cb68e3f85f4a463.jpg",
+        "table_caption": [
+            "Table 3: Comparison between the constituency parser and scene graph parser. For CC-500 prompts, both parsers end up with the same results. As for general prompts, scene graph parser tends to generate more text spans with middle concepts appearing multiple times across different spans. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Constituency Parser</td><td rowspan=1 colspan=1>Scene Graph Parser</td></tr><tr><td rowspan=2 colspan=1>Example 0</td><td rowspan=1 colspan=2>CC-500 Prompt: A white sheep and a red car</td></tr><tr><td rowspan=1 colspan=1>“A white sheep”,“a red car”</td><td rowspan=1 colspan=1>“A white sheep”,“a red car”</td></tr><tr><td rowspan=2 colspan=1>Example 1</td><td rowspan=1 colspan=2>Prompt: A silver car with a black cat sleeping on top of it</td></tr><tr><td rowspan=1 colspan=1>“A silver car”,“a black cat”,“A silver car with a black cat”</td><td rowspan=1 colspan=1>“A silver car”,&quot;a black cat”,“top of it”,“a black cat sleeping on top of it&quot;</td></tr><tr><td rowspan=2 colspan=1>Example 2</td><td rowspan=1 colspan=2>Prompt:A horse running in a white field next to a black and green pole</td></tr><tr><td rowspan=1 colspan=1>“Ahorse”,“a white feld&quot;,“a black and green pole&quot;,“a white field next to a black and green pole”</td><td rowspan=1 colspan=1>“Ahorse”,“a white field”,“a black and green pole”,“A horse running in a white field&quot;</td></tr><tr><td rowspan=2 colspan=1>Example 3</td><td rowspan=1 colspan=2>Prompt:Rice with red sauce with eggs over the top and orange slices on the side</td></tr><tr><td rowspan=1 colspan=1>“red sauce”,“the side”,“the top and orange slices”,“the top and orange slices on the side&quot;</td><td rowspan=1 colspan=1>“red sauce”,“the side”,“the top and orange slices”,“Rice with red sauce”,“red sauce with eggs”,“the top and orange slices on the side&quot;,“red sauce with eggs over the top and orange slices”</td></tr><tr><td rowspan=2 colspan=1>Example 4</td><td rowspan=1 colspan=2>Prompt:A pink scooter with a black seat next to a blue car</td></tr><tr><td rowspan=1 colspan=1>“A pink scooter”,“a black seat”,“a blue car”</td><td rowspan=1 colspan=1>“A pink scooter”,“a black seat”,“a blue car”,&quot;a pink scooter with a black seat&quot;,“a black seat next to a blue car”</td></tr></table>",
+        "bbox": [
+            173,
+            102,
+            821,
+            400
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/5505e9c9fabb63da9b36d9e776d538f607231efc48fb6c2f6bc627e1951a2d11.jpg",
+        "image_caption": [
+            "Figure 12: Synthesized images corresponding to prompts in Table 3. Yellow boxes annotate compositions that are improved using different parsers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            468,
+            821,
+            696
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            766,
+            825,
+            878
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/9a323a017b67c428078490d9067e77f606d8f54878028c43b59103d5e505fc9b.jpg",
+        "image_caption": [
+            "Figure 13: Qualitative results on CC-500 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            55,
+            820,
+            883
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Stable Diffusion ",
+        "text_level": 1,
+        "bbox": [
+            200,
+            164,
+            267,
+            193
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Ours ",
+        "text_level": 1,
+        "bbox": [
+            312,
+            171,
+            352,
+            184
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Stable Diffusion ",
+        "text_level": 1,
+        "bbox": [
+            416,
+            164,
+            483,
+            193
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Ours ",
+        "text_level": 1,
+        "bbox": [
+            529,
+            171,
+            568,
+            185
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Stable Diffusion ",
+        "text_level": 1,
+        "bbox": [
+            632,
+            164,
+            699,
+            193
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Ours ",
+        "text_level": 1,
+        "bbox": [
+            745,
+            171,
+            782,
+            184
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "a purple cat with a orange hat on its head ",
+        "bbox": [
+            189,
+            199,
+            379,
+            224
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A red cat sits on a rug with a black cord ",
+        "bbox": [
+            410,
+            200,
+            588,
+            227
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A yellow cat is wearing a blue plastic baseball hat. ",
+        "bbox": [
+            620,
+            199,
+            805,
+            226
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/660bc275b91b59866cd20e3a88baefb5a552b3ad21116d920fca9476c0987944.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            400,
+            229,
+            598,
+            305
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/44f8df4e6174cfaee77c876deda6de6350198075800255d17326b31cbf9a0166.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            614,
+            231,
+            810,
+            306
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/26a9991969c15534788eae2f5acc0d8cda40c915d13508aea40a64234a837dfe.jpg",
+        "image_caption": [
+            "A red helmet is on a yellow toilet in the dirt "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            229,
+            382,
+            305
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A red stop sign above a white walk across road sign ",
+        "bbox": [
+            408,
+            327,
+            591,
+            353
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Two elephants walking by a green wall with tan palm trees painted on it ",
+        "bbox": [
+            619,
+            318,
+            808,
+            357
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/cfd38b6e692be180d8d214269d4b921af9c6ea51e92262d22844436ebebe2b8b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            359,
+            380,
+            435
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/408e26c582eccff899a6069e2265d99daf61980c8cc47f66c6c8328d8054ffd6.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            401,
+            359,
+            598,
+            436
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c5f1e143277e8913a928bce5fd0f6aacb27ceb05fed39986d71058a5a715923.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            616,
+            359,
+            810,
+            436
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A bathroom with red tile and a green shower curtain ",
+        "text_level": 1,
+        "bbox": [
+            186,
+            458,
+            379,
+            484
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A spacious kitchen has white walls , red countertops , and a large stove ",
+        "bbox": [
+            406,
+            450,
+            593,
+            491
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A large white bed sitting in a hotel room next to a red couch ",
+        "bbox": [
+            624,
+            450,
+            802,
+            491
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a43f884cd58a3781a856b40d946e06aa95a3781630c49ecd2683d6082a67e4e.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            492,
+            379,
+            568
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/91f6e969166829de16eb4f631fbb73f19ef0d5390410d037d4a690f99df02786.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            401,
+            492,
+            598,
+            568
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/c40deaf2eb3b4751d7c5816cee4083bcc77c9b78e322402b3ca26513daf3706d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            616,
+            492,
+            812,
+            568
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A pink towel stands out greatly in the white bathroom ",
+        "bbox": [
+            408,
+            588,
+            596,
+            616
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/bacd240485e26a532174d993863ebd922208a129b432bdb6bcd36b94119a092b.jpg",
+        "image_caption": [
+            "A white toilet bowl with a purple rug in front "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            621,
+            379,
+            695
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A large pizza on a white plate sitting on a blue table ",
+        "text_level": 1,
+        "bbox": [
+            622,
+            590,
+            805,
+            617
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/fc3d8bd9df11cad37a11762b0e2c5fd1165c80053f07eca502b775632458b10e.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            401,
+            621,
+            599,
+            695
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/48b52b815f2fadf7e93602f86d613241414c34c280fa91397edfec9c1c36a9c5.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            616,
+            621,
+            812,
+            695
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A spoon and bowl of red pea soup and green beans with onions ",
+        "bbox": [
+            192,
+            718,
+            372,
+            757
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A cow standing outside of a white building with a blue entrance ",
+        "bbox": [
+            413,
+            717,
+            584,
+            756
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "A black and white curtain   \nhanging in a room that is   \ndecorated in black, white and   \nred ",
+        "bbox": [
+            620,
+            705,
+            807,
+            758
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/b7fd1fb2b097479ee0c8daa0225ada709939a000e386f9227ee3d53632006091.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            401,
+            758,
+            599,
+            835
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fd1de4853b4e135bbd29c014613e0ba1aebc6158a4201d581f5433d4629e15d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            617,
+            758,
+            813,
+            835
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/d5d8e5dbed72e828a9bba99342c7933385ffcda9b12e7d2758d88218380089c8.jpg",
+        "image_caption": [
+            "Figure 14: Qualitative results on ABC-6K "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            758,
+            383,
+            835
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/cfdda3c5e52b24145788d8db72809206b16643bae64a24cf322cb9114b08223e.jpg",
+        "image_caption": [
+            "Figure 15: Qualitative results characterizing attributes beyond colors, including shape, size and materials. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            171,
+            818,
+            797
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/228590b790dbd98fc2e4f38e8af5d5b6c518ba667976fe594af7a5e67dfcd7e5.jpg",
+        "image_caption": [
+            "Figure 16: A prompt “an astronaut riding a horse” appended with different (combinations of) style descriptions. Our method has no negative effects on the image style. “base” refers to Stable Diffusion. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            107,
+            813,
+            852
+        ],
+        "page_idx": 20
+    }
+]

parse/dev/TrjbxzRcnf-/TrjbxzRcnf-.md

@@ -0,0 +1,447 @@
+# MEMORIZING TRANSFORMERS
+
+Yuhuai Wu, Markus N. Rabe, DeLesley Hutchins, Christian Szegedy
+
+{yuhuai,mrabe,delesley,szegedy}@google.com
+
+# ABSTRACT
+
+Language models typically need to be trained or finetuned in order to acquire new knowledge, which involves updating their weights. We instead envision language models that can simply read and memorize new data at inference time, thus acquiring new knowledge immediately. In this work, we extend language models with the ability to memorize the internal representations of past inputs. We demonstrate that an approximate $k \mathbf { N N }$ lookup into a non-differentiable memory of recent (key, value) pairs improves language modeling across various benchmarks and tasks, including generic webtext (C4), math papers (arXiv), books (PG-19), code (Github), as well as formal theorems (Isabelle). We show that the performance steadily improves when we increase the size of memory up to 262K tokens. On benchmarks including code and mathematics, we find that the model is capable of making use of newly defined functions and theorems during test time.
+
+# 1 INTRODUCTION
+
+Transformers (Vaswani et al., 2017) have led to remarkable progress in natural language processing (Devlin et al., 2019; Brown et al., 2020), mathematical reasoning (Polu & Sutskever, 2020; Wang et al., 2020a; Rabe et al., 2021; Li et al., 2021; Hahn et al., 2021; Cobbe et al., 2021), and program synthesis (Austin et al., 2021; Chen et al., 2021; Li et al., 2022). However, transformer performance on many of these tasks is limited by the context length of attention, which is typically short. The ability to attend to far-away tokens is important in many situations. In novels, characters and events are referenced across multiple chapters. In source code, references to classes and functions may occur quite far from the places in which they are defined. In theorem proving, proofs make use of previously defined lemmas.
+
+Attention over long sequences is also useful as a form of rapid learning. Facts and information which are stored in the form of weight matrices must be slowly trained over hundreds of thousands of training steps. By using attention, however, a model can simply memorize facts (e.g. function definitions) by storing them as (key, value) pairs in long-term memory, and then retrieve those facts later by creating a query that attends to them. In this case, attention acts as a form of information retrieval, allowing the model to look up facts that it has seen previously.
+
+We demonstrate that a simple and effective way to increase the size of the attention context is to use approximate $k$ -nearest-neighbor $( k \mathsf { N N } )$ lookup, which is widely used in information retrieval. A number of extremely scalable implementations of $k \mathbf { N N }$ lookup are available, such as ScaNN (Guo et al., 2020) and Faiss (Johnson et al., 2021).
+
+There are two things which distinguish our approach from previous work on long-range attention (c.f. Section 2). First, unlike some other approaches, $k \mathbf { N N }$ lookup does not do averaging or summarization of tokens at long distances, but retrieves exact values even from the distant context.
+
+Second, gradients are not backpropagated into the external memory, which is critical to the scalability of our technique. The keys and values are a function of model parameters, so attempting to backpropagate gradients into external memory would necessarily involve computing all of the keys and values with the current model parameters on every training step. However, if the external memory is not differentiable, then we can instead instead reuse keys and values that were previously computed on prior training steps, which drastically reduces the amount of computation for large memories. With our technique, we are easily able to scale external memory up to sequence lengths of 131k or 262k tokens on a single TPU device, while maintaining a reasonable step time.
+
+![](images/c348262572039ee17a0180d1f12a1ab33318f7e59c45735bf4ae47b93ca7fd68.jpg)  
+Figure 1: Adding a memory of 8K tokens improves perplexity across different model sizes.
+
+We show that model perplexity steadily improves with the size of external memory on a variety of language modelling tasks, including C4 (long documents only), Github code repositories, PG-19 books, formal proofs in Isabelle, and arXiv math papers. We further show that models can generalize to larger memory sizes than they were trained on: models trained with a small memory show gains from using a much larger memory at inference time. Finally, we show that our models are actually using memory in the way that we had hoped, e.g. by looking up the definitions of lemmas in a theorem proving corpus.
+
+The simplicity of the changes to the Transformer architecture allows us to easily integrate this approach into existing code bases, including extremely large language models. We further show that the improvements to quality are maintained across models of increasing size, and that the model improvements gained from adding memory are even larger than increasing the size of the model by 5X or more as shown in Figure 1.
+
+# 2 RELATED WORK
+
+A great deal of work has been done on efficient long-range attention mechanisms; see Tay et al. (2020; 2021) recent surveys. Sliding windows (Beltagy et al., 2020) use a long sequence, but attend within a smaller window, thus reducing complexity to the window size, rather than total sequence length. Approximate mechanisms such as Linformer (Wang et al., 2020b), and Performer (Choromanski et al., 2021) refactor the attention matrix by using a different kernel than softmax to obtain $O ( N )$ complexity. Pooling strategies such as Hierarchical 1D attention (Zhu & Soricut, 2021), and Combiner (Ren et al., 2021) apply pooling or averaging over tokens at longer distances. Sparse strategies such as Big Bird (Zaheer et al., 2020) select only a subset of tokens to attend to; Routing Transformers (Roy et al., 2021) use clustering to select the subset, while Reformer (Kitaev et al., 2020) relies on hashing. Hierarchical mechanisms (Ainslie et al., 2020) combine multiple tokens into phrases or sentences to reduce sequence length. Expire-span (Sukhbaatar et al., 2021) prunes far-away tokens that it learns are “unimportant”. (Zemlyanskiy et al., 2021) process long sequences in two passes with different encoders. The second pass is given a lot of context by accessing summaries of the first pass.
+
+Feedback transformers (Fan et al., 2020) use a recurrent architecture in which each token attends to the output of the final layer instead of the previous layer. Recurrence does not increase the size of the attention context itself, but it expands the receptive field at the cost of parallelism and training speed.
+
+Truncated backpropagation through time (Williams & Peng, 1990) was originally introduced as a way of training recurrent neural networks (RNN) over very long sequences, when the entire sequence does not fit in memory. The sequence is chopped into segments, and after each training step, the final RNN state for the segment is saved in a non-differentiable cache, and used as the initial state on the next training step. Neural caches (Grave et al., 2017) extend the cache to contain a record of many prior hidden states, and attend over them. Transformer-XL (Dai et al., 2019) applies this technique to transformers; it caches the (key,value) pairs computed from the previous training step, and uses them as a prefix for the tokens on the next training step, which yields significant gains on long documents. Rae et al. (2020) improve over Transformer-XL by compressing the tokens before adding them to the cache. In contrast, we use a very large cache without compression, combined with an approximate $k \mathbf { N N }$ attention mechanism over it.
+
+![](images/93d8466b573b5325cd9a069c63eddcdd2572eb8799f9d4720b8a3dbfc7a46115.jpg)  
+Figure 2: We extend Transformers with access to (key, value) pairs of previously seen subsequences.
+
+Sukhbaatar et al. (2019) make the observation that the feed-forward portion of a transformer layer functions very much like attention if one replaces the ReLU activation with softmax. They implement a combined attention over both tokens from the input sequence and a learned (and differentiable) “memory”. Lample et al. (2019) exploit this observation to replace the feed-forward layers (FFNs) with a fast $k \mathbf { N N }$ lookup over a much larger “memory”, and achieve large gains in model accuracy without significant computation overhead. (We use $k \mathbf { N N }$ lookup to approximate attention to previous tokens, not to replace the FFN.)
+
+Non-differentiable external memory has been used in different ways by Khandelwal et al. (2020), who run a pre-trained model over an entire corpus, and construct a large table of (key, token) pairs. They then use that table to replace the final softmax layer for token selection in the model, which results in significant improvements in language modeling. Yogatama et al. (2021) extend this approach by a gating mechanism and a process to compress the context into keys for retrieval.
+
+There are several works that combine retrieval with transformers. REALM (Guu et al., 2020), MARGE (Lewis et al., 2020a), RAG (Lewis et al., 2020b), and composite memory for dialog (Fan et al., 2021) retrieve documents from a knowledge base to improve question answering or dialogue. The knowledge base consists of text snippets and is static and typically separate from the inputs and outputs of the models. Instead, we focus on language modeling using a decoder-only model, and propose a simple model that unifies attention and retrieval.
+
+$k$ -nearest-neighbor lookup is a general-purpose technique that is used for a wide variety of machine learning and retrieval tasks, and high-performance implementations are available for various architectures (Johnson et al., 2021; Guo et al., 2020). Memory-efficient Transformers (Gupta et al., 2021) replace dense attention with a $k \mathbf { N N }$ lookup to increase speed and reduce memory usage.
+
+# 3 METHOD
+
+The architecture of our $k \mathbf { N N }$ -augmented transformer is shown in Figure 2. The bulk of the model is a vanilla, decoder-only transformer (Vaswani et al., 2017). The input text is tokenized, and the tokens are embedded into vector space. The embedding vectors are passed through a series of transformer layers, each of which does dense self-attention, followed by a feed-forward network (FFN). Since this is a decoder-only language model, we use a causal attention mask and the token embeddings of the last layer are used to predict the next token.
+
+Long documents are split into subsequences of 512 tokens, and each subsequence is used as the input for one training step. In contrast to standard practice, we do not shuffle the subsequences; instead, each long document is fed into the transformer sequentially, from beginning to end, as is done with Transformer-XL (Dai et al., 2019).
+
+![](images/81f98de49b0afcae04d1631ab7e72f49483236312e44999b1680cfebdad0dc90.jpg)  
+Figure 3: Our data pipeline splits documents into subsequences and packs subsequences into batches.
+
+We also use a Transformer-XL style cache, which holds the keys and values from the previous training step. When doing self-attention, the cached keys and values are prepended to the current keys and values, and we use a sliding-window causal mask (Beltagy et al., 2020) so that each token has a local context that includes the previous 512 tokens.
+
+# 3.1 $k$ NN-AUGMENTED ATTENTION LAYER
+
+One of the transformer layers near the top of the stack is a kNN-augmented attention layer, which combines two forms of attention. Like all of the other layers, it uses standard dense self-attention on the local context, which is the input subsequence for the current training step. Unlike the other layers, however, it also does an approximate $k$ -nearest-neighbor search into the external memory.
+
+The same queries are used for both the local context, and for the external memory. The keys and values also belong to the same distribution; after each training step, the (key, value) pairs in the local context are appended to the end of the external memory. If the document is very long, old (key, value) pairs will be dropped from the memory to make room for new ones. Thus, for each head, the external memory keeps a cache of the prior $M$ (key, value) pairs, where $M$ is the memory size.
+
+The $k \mathbf { N N }$ lookup will return a set of retrieved memories, which consist of the top- $k$ (key, value) pairs that $k \mathbf { N N }$ search returns for each query (i.e. each token) in the input subsequence. As with standard dense attention, we first construct an attention matrix by computing the dot product of each query against the retrieved keys, then apply softmax, and finally return a weighted sum of the retrieved values. Unlike standard dense attention, the retrieved memories contain a different set of (key, value) pairs for each query.
+
+Attention over the local context is performed in the usual way. The results of $k \mathbf { N N }$ -attention and local attention are then combined using a learned gate:
+
+$$
+\begin{array} { c } { { g = \sigma ( b _ { g } ) } } \\ { { V _ { a } = V _ { m } \odot g + V _ { c } \odot ( 1 - g ) } } \end{array}
+$$
+
+where $\sigma$ is the sigmoid function, and $\odot$ is element-wise multiplication. $V _ { a }$ is the combined result of attention, $V _ { m }$ is the result of attending to external memory, and $V _ { c }$ is the result of attending to the local context. The bias $b _ { g }$ is a learned per-head scalar parameter, which allows each head to choose between local and long-range attention. In our experiments, the value of the gate $g$ does not depend on the content of the token at each position, although that would be a trivial extension to implement. We did observe that over time, most heads learned to attend almost exclusively to external memory.
+
+Position bias. For dense attention within the local context, we use the T5 relative position bias (Raffel et al., 2020). As noted by Dai et al. (2019), adding a global position encoding to each token does not work well when processing long documents. We don’t use a position bias for the retrieved memories. Experiments on the PG19 dataset (Sun et al., 2021) have shown that relative position does not appear to matter at long range, and the T5 relative bias puts all long-range tokens in the same bucket anyway.
+
+Batching. Figure 3 illustrates how multiple long documents of different lengths are packed into a batch, and split into subsequences. Each subsequence in the batch comes from a different document, and thus requires a separate external memory, which is cleared at the start of each new document.
+
+# 3.2 DISTRIBUTIONAL SHIFT
+
+Because each long document is processed over multiple training steps, there is a distributional shift in the keys and values that are stored in external memory. The model parameters that produce the queries change over time, and will thus have shifted since the keys and values were stored. For very large memories, older records may become “stale.” Similar observations have been made for CrossBatch memory (Wang et al., 2020c) in the vision domain.
+
+To reduce the effects of staleness, we normalize keys and queries (Henry et al., 2020). Normalization does not eliminate staleness, but it at least ensures that older keys and newer keys do not differ in magnitude. We also found that normalization helps stabilize training with the Transformer-XL cache.
+
+In some of our experiments, we observed that training models from scratch with a large memory sometimes resulted in worse performance than pretraining the model with a small memory of size 8192, and then finetuning it on a larger memory. This training instability could be due to staleness. However, models seem to be able to cope with a limited degree of staleness (with the small memory) by adjusting their queries accordingly.
+
+# 3.3 APPROXIMATE $k \mathbf { N N }$
+
+We employ approximate $k \mathbf { N N }$ search rather than exact $k \mathbf { N N }$ search because it significantly improves the computational speed of our model. We use a simple approximation of $k \mathbf { N N }$ for TPUs, which has a recall of about $90 \%$ , i.e. $90 \%$ of the true top $k$ are returned in the approximate top $k$ . There are various other efficient approximate $k \mathbf { N N }$ algorithms available for CPU and GPU/TPU, for example through Faiss (Johnson et al., 2021) or ScaNN (Guo et al., 2020), which can scale into the billions.
+
+# 4 EXPERIMENTS
+
+We evaluate the effect of adding external memory on five language modeling tasks, all of which involve long-form text: English language books (PG-19), long web articles (C4), technical math papers (arXiv Math), source code (Github), and formal theorems (Isabelle). The results show significant improvements in the perplexity of the model with the addition of external memory. We experimented with various sizes of external memory, from 1536 to as high as 262K. On most of the datasets, there was an initial sharp gain from adding a small external memory, followed by smaller but steadily increasing gains as the size of the memory was increased.
+
+# 4.1 DATASETS
+
+arXiv Math For the arXiv dataset, we collected a corpus of papers by downloading them via the arXiv Bulk Data Access1. We filtered papers to include only articles labeled as “Mathematics” and whose $\mathrm { I A T } \mathrm { E } ^ { \mathrm { X } }$ source was available. The number of tokens per paper in this dataset is roughly comparable to the number of tokens per book in PG19, because $\mathrm { I A T } \mathrm { E } ^ { \mathrm { X } }$ source has many special characters and the tokenizer tends to output small subwords.
+
+Github We used BigQuery2 to obtain a large corpus of Github repositories that are published with open-source licenses. We used file endings to filter for files in the languages C, $\mathrm { C } { + + }$ , Java, Python (including Jupyter notebooks), Go, and TypeScript. Individual source code files are often fairly short, and there are many dependencies and cross-references between files in the repository. To capture these dependencies, we created one long document for each Github repository by traversing the directory tree, and concatenating all of the files within it. The order in which files are traversed within the repository is random, but each subdirectory is processed as a unit, so that all the files within the subdirectory are close to each other in the resulting document. Source code is usually structured so that related files are all grouped together in the same subdirectory; this traversal preserves that structure, while still shuffling files and subdirectories in random order.
+
+Formal Math – Isabelle The Isabelle corpus consists of formal mathematical proofs of theories. We collected all 627 theories available on The Archive of Formal Proofs3 (as of October 6, 2021) and an additional 57 theories from the Isabelle standard library4 to create a corpus of 684 theories. All theories have open-source licenses. Each theory is a self-contained mathematical object, on topics such as foundational logic, advanced analysis, algebra, or cryptography, and consists of multiple files containing proofs. As with the Github corpus, all files that make up a theory are concatenated together into one long document. Unlike the Github corpus, we order the files according to their import dependencies, so that later files use sub-theorems that are proved in earlier files.
+
+Table 4: Average token-level perplexities of each model when trained for 500k steps.   
+
+<table><tr><td>Context</td><td>Memory</td><td>XL cache</td><td>arXiv</td><td>PG19</td><td>C4(4K+)</td><td>GitHub</td><td>Isabelle</td></tr><tr><td>512</td><td>None</td><td>None</td><td>3.29</td><td>13.71</td><td>17.20</td><td>3.05</td><td>3.09</td></tr><tr><td>2048</td><td>None</td><td>None</td><td>2.69</td><td>12.37</td><td>14.81</td><td>2.22</td><td>2.39</td></tr><tr><td>512</td><td>None</td><td>512</td><td>2.67</td><td>12.34</td><td>15.38</td><td>2.26</td><td>2.46</td></tr><tr><td>2048</td><td>None</td><td>2048</td><td>2.42</td><td>11.88</td><td>14.03</td><td>2.10</td><td>2.16</td></tr><tr><td>512</td><td>1536</td><td>None</td><td>2.61</td><td>12.50</td><td>14.97</td><td>2.20</td><td>2.33</td></tr><tr><td>512</td><td>8192</td><td>None</td><td>2.49</td><td>12.29</td><td>14.42</td><td>2.09</td><td>2.19</td></tr><tr><td>512</td><td>8192</td><td>512</td><td>2.37</td><td>11.93</td><td>14.04</td><td>2.03</td><td>2.08</td></tr><tr><td>512</td><td>65K</td><td>512</td><td>2.31</td><td>11.62</td><td>14.04</td><td>1.87</td><td>2.06</td></tr><tr><td>2048</td><td>8192</td><td>2048</td><td>2.33</td><td>11.84</td><td>13.80</td><td>1.98</td><td>2.06</td></tr><tr><td>2048</td><td>65K</td><td>2048</td><td>2.26</td><td>11.37</td><td>13.64</td><td>1.80</td><td>1.99</td></tr></table>
+
+$\mathbf { C 4 } ( 4 \mathbf { K } + )$ C4, the colossal cleaned common crawl, is a very large collection of documents that have been scraped from the internet (Raffel et al., 2020). We filtered out all documents that have less than 4096 tokens to focus on documents where memory can have an impact.
+
+PG-19 PG-19 is a large dataset of English-language books, published prior to 1919, which were retrieved from the Project Gutenberg archive (Rae et al., 2020; Sun et al., 2021). PG-19 is one of the few public datasets that only contains full-length books, and has become a benchmark for long-range natural language text modeling.
+
+# 4.2 EXPERIMENTAL METHOD
+
+We used a 12-layer decoder-only transformer (with and without Transformer-XL cache) with an embedding size of 1024, 8 attention heads of dimension 128, and an FFN hidden layer of size 4096. For all of our experiments, we used $k = 3 2$ . Unless specified otherwise, we use the 9th layer as the $k \mathbf { N N }$ augmented attention layer. We used a sentence-piece (Kudo & Richardson, 2018) tokenizer with a vocabulary size of 32K.
+
+We used the Adafactor optimizer (Shazeer & Stern, 2018). In preliminary experiments, we conducted a hyperparameter search to determine the optimal learning rate among three choices ({3.0, 1.0, $3 \cdot { \bar { 1 0 } } ^ { - 1 } \}$ ), and found that 1.0 works best. We used a linear warmup schedule for the first 1000 steps, followed by square root decay. We trained the models from scratch for 500K steps on all the datasets, except for the Isabelle dataset. Isabelle is small, so we stopped training after 100K steps when the model began to overfit. We ran all of our experiments on 32 TPU cores. Our models were implemented in JAX (Bradbury et al., 2018) and Flax (Heek et al., 2020).
+
+When comparing models with different context lengths, we adjusted the batch size (the number of documents in a batch) so that there are always $2 ^ { 1 7 }$ tokens in a batch. E.g., a model with a context length of 512 has a batch size of 256, while the 2048 model has a batch size of 64.
+
+We experimented with multiple implementations of approximate $k \mathbf { N N }$ lookup with different tradeoffs between quality and computational cost. We did not observe a significant degradation of the model quality when switching to lower quality approximations of $k \mathbf { N N }$ , so the model appears to be quite robust with respect to the quality of $k \mathbf { N N }$ retrieval. For a model with around 200M trainable parameters the step time increased from 0.2s to $0 . 2 5 \mathrm { s }$ when we added a memory of size 8K, and to 0.6s when we added a memory of size 65K (measured on TPUv3).
+
+# 4.3 EFFECT OF EXTERNAL MEMORY
+
+Adding external memory results in substantial gains across datasets and architectures, as shown in Table 4. Across all five datasets, adding external memory to either the vanilla Transformer or the Transformer-XL architecture improves perplexity by a substantial amount. For example, on $\mathrm { C 4 } ( 4 \mathrm { K } + )$ dataset, adding memory of size 8192 improves the perplexity of the vanilla Transformer (with context size 512) from 17.20 to 14.42, and improves Transformer-XL from 15.38 to 14.04.
+
+<table><tr><td>Context</td><td>Pretrain</td><td>Fine-tune</td><td>Perplexity</td></tr><tr><td>512</td><td>8192</td><td>None</td><td>2.37</td></tr><tr><td>512</td><td>65K</td><td>None</td><td>2.31</td></tr><tr><td>512</td><td>8192</td><td>65K</td><td>2.32</td></tr><tr><td>512</td><td>8192</td><td>131K</td><td>2.30</td></tr><tr><td>512</td><td>8192</td><td>262K</td><td>2.26</td></tr><tr><td>2048</td><td>8192</td><td>None</td><td>2.33</td></tr><tr><td>2048</td><td>65K</td><td>None</td><td>2.26</td></tr><tr><td>2048</td><td>65K</td><td>131K</td><td>2.23</td></tr><tr><td>2048</td><td>65K</td><td>262K</td><td>2.21</td></tr></table>
+
+Table 5: Finetuning for 20K steps to make use of a larger memory on the arXiv data set.
+
+Increasing the size of the memory increases the benefit of the memory. The best perplexities for all datasets and architectures were obtained with a memory size of 65K.
+
+Note that Transformer-XL with context size 2048 already has a theoretical receptive field that is quite large. Each token in a higher layer can attend up to 2048 tokens away in the layer below, so the total receptive field is $2 0 4 8 \cdot 1 2$ (layers) $\sim 2 5 \mathrm { K }$ . Nevertheless, we still saw a substantial gain when adding an external memory of size 8192 to this model. $k \mathbf { N N }$ attention into memory would appear to be a more effective way to retrieve information from the distant past than the Transformer-XL cache.
+
+On the other hand, we also saw improvements by adding XL cache to the large-memory (65K) models. In a vanilla (non-XL) Transformer, the first few tokens in a sequence have very little context, and thus have higher perplexity. The XL cache provides additional local short-range context at the start of a sequence, which complements the long-range context provided by external memory.
+
+Interestingly, in a vanilla Transformer, using even a small external memory of size 1536 provides a gain in perplexity which is almost as good as using a local context of size 2048 but no memory (e.g. Table 4). This is surprising, because the external memory is not differentiable, and is added only to one layer of the Transformer, whereas increasing the context size is differentiable and affects all layers. We conclude that the lower layers of a Transformer don’t necessarily need long-range context, and having a differentiable memory is not as important as one might suspect.
+
+# 4.4 SCALING TO LARGER MODELS
+
+We scaled up the Transformer model to sizes of 1 and 8 billion parameters. For the 1 billion parameter model, we use 8 layers, 32 heads with head dimension 128, $d _ { - }$ model 2048, and $d _ { - }$ _ff 16384. For the 8 billion parameter model, we use 64 heads, 16 layers, $d$ _model 4096, and $d _ { - }$ _ff 32768. We used a context size of 2048, memory size of 8192, and no XL cache. We ran the comparisons to the vanilla Transformer on the arXiv math dataset. Scaling plots are shown in Figure 1.
+
+External memory provides a consistent improvement to the model as it is scaled up. Remarkably, we found that the smaller Memorizing Transformer with just 8k tokens in memory can match the perplexity of a larger vanilla Transformer which has 5X more trainable parameters.
+
+# 4.5 FINETUNING ON LARGER MEMORIES
+
+Finetuning on a larger memory. In some cases, training was unstable when using large memories, possibly due to distributional shift early in the training (See Section 3.2). Thus, for memories of 131K or more tokens, we first pretrain the model with a memory size of 8192 or 65K for 500K steps, and then finetune it with the larger memory for an additional 20K steps. The results of finetuning on the arXiv Math data set are shown in Table 5. Increasing the size of external memory provided consistent gains up to a size of 262K. Note that 262K tokens is longer than almost all of the documents in arXiv, and thus we would not expect to see any gain past this point (see Appendix A).
+
+![](images/14d1bef481a2ec3931ed59a899d428ebe8a68caed797c0d03c05a6ce7c996ad0.jpg)  
+Figure 6: Finetuning a 1B vanilla Transformer model to use external memory of size 65K.
+
+Finetuning a non-memory model to use memory Pretraining can be very costly both in time and computational resources. Thus, a natural question to ask is: can one fine-tune a pretrained Transformer to use external memory? The answer is yes!
+
+We took a pre-trained 1B vanilla Transformer model, and fine-tuned it to use external memory (the 1B models used in Section 4.4). The fine-tuning result is shown in Figure 6. Notice that the model quickly learns to use external memory. Within 20K steps $4 \%$ of the pre-training time) the fine-tuned model has already closed $8 5 \%$ of the gap between it and the 1B Memorizing Transformer, and after $1 0 0 \mathrm { k }$ steps it has closed the gap entirely.
+
+# 4.6 INFORMATION RETRIEVAL PATTERNS
+
+We conducted a qualitative study of what the model was actually retrieving from external memory, by finding which tokens showed the biggest improvements in cross-entropy loss when the size of the memory was increased, and then examining the top- $k$ retrieved memories for those tokens. We found that the model gained the most when looking up rare words, such as proper names, references, citations, and function names, where the first use of a name is too far away from subsequent uses to fit in the local context. This result is in keeping with the prior analysis of long-context Transformers on PG19 (Sun et al., 2021), which found similar lookup patterns. For this experiment, we used a slightly older version of the architecture without the gating mechanism.
+
+Which tokens show a benefit from memory? Figure 7 shows a visualization of which tokens show an improvement when the size of the external memory is increased. We selected a math paper at random, and plotted the difference in cross entropy loss for each token $x _ { i }$ in the paper, comparing two models with the same parameters, but with memories of different sizes. $\Delta _ { i } = \mathrm { c r o s s - e n t r o p y } _ { 8 1 9 2 } ( x _ { i } )$ $- \mathrm { c r o s s - e n t r o p y } _ { 3 2 \mathrm { K } } ( x _ { i } )$ . Positive values show an improvement in loss.
+
+The $x$ -axis on the chart is the token number $i$ , while the $y$ -axis is $\Delta _ { i }$ . For the first 8192 tokens, the difference between the two models is zero, since the larger capacity of the 32K memory isn’t being used yet. However, after token 8193, we can see that the larger memory helps, on average, over the smaller memory. The benefit is not universal, since the predictions for some tokens become worse, possibly due to the fact that a relevant retrieved memory no longer makes it into the top- $k$ when the size of the external memory is increased. This figure also shows that the benefit of external memory is somewhat sparse. The improvement in perplexity seems to be mainly driven by a small percentage of tokens that obtain a large improvement in cross-entropy loss when using the larger memory.
+
+What information is being looked up? Given that only a subset of tokens shows improvement from external memory, we did a further investigation into what, exactly, those tokens are using the memory for. We took those tokens which showed the largest improvement in cross-entropy loss, and for each of them tokens, we examined the top- $k$ retrieved memories. We studied arXiv math, Github and Isabelle corpus. For arXiv math and Github, we found the model retrieved function and variable names. See more details with examples in Appendix B.
+
+![](images/ac7dcbfadeffdce1e7c62204b4feff0227f84bf9079091c5be4d5700f286a668.jpg)  
+Figure 7: Difference in loss for each token in a randomly chosen paper, using the same model once with a memory size of 8K and once with 32K. Higher numbers mean the longer memory helped in comparison to the shorter memory. This paper is 22K tokens long.
+
+Table 8: Examples of memory retrieval in the Isabelle dataset. The model is able to find the definition of a lemma from a reference to it. The retrieved surrounding context (highlighted) is the definition body of the mathematical object highlighted in the querying context.   
+
+<table><tr><td></td><td></td><td></td><td>Query indexInputTargetSurrounding context</td><td></td><td>Retrieved index Retrieved surrounding context</td></tr><tr><td>29721</td><td>mark</td><td>ov</td><td>rule prob_space. markov_inequality</td><td>8088</td><td>M.t\&lt;le&gt; X a} \&lt;le&gt; expectation X /t&quot;</td></tr><tr><td>40919</td><td>1</td><td>th</td><td>= ( subgraph_threshold Hn / p n)</td><td>27219</td><td>threshold H n = n powr (-(1 / max_density’</td></tr><tr><td>49699</td><td>S</td><td>W</td><td>assumes&#x27; orthonormal_system Sw&quot;</td><td>28050</td><td>definition orthonormal_system “</td></tr></table>
+
+Retrieving mathematical definitions. Our case study on the Isabelle corpus provides one of the clearest illustrations of how a model can make good use of external memory. When predicting the name of a mathematical object or a lemma, the model looked up the definition from earlier in the proof. Examples of this behavior are shown in Table 8. In example 1, the model retrieves a definition within the body of a lemma, markov_inequality. In example 2, it retrieves the definition of a previously defined concept subgraph_threshold. In example 3, it retrieves the definition of orthonormal_system. We manually checked 10 examples where the model made a prediction of lemma names, and 8 out of 10 times model found the body of the lemma it needs to predict. In the other two cases, the model also looked up materials in the immediate vicinity. To the best of our knowledge, this is the first demonstration that attention is capable of looking up definitions and function bodies from a large corpus. The Isabelle case study used a model with two memory layers of size 32K.
+
+# 5 CONCLUSION
+
+We present a simple extension to the Transformer architecture, called kNN-augmented attention, which dramatically increases the length of the context that a language model can attend to by using $k$ -nearest-neighbor lookup into a large external memory. We demonstrate the effectiveness of external memory in a series of language modeling experiments over a variety of long-document datasets, including LaTeX documents, source code, formal proofs, and books.
+
+The Memorizing Transformer shows large improvements in perplexity over the baseline for all of the data sets and architectures that we studied; it is comparable to a vanilla transformer that has 5 times the number of parameters. Perplexity continues to improve with increasing memory size, although there is a point of diminishing returns. Moreover, external memory continues to provide benefits even as the transformer is scaled up from 200M to 8B parameters. Perhaps most intriguingly, a Memorizing Transformer does not need to be pre-trained from scratch; it is possible obtain large gains from adding memory to an existing pre-trained model, and then fine-tuning it.
+
+Unlike other forms of attention, $k \mathbf { N N }$ retrieval can be easily scaled up to huge memory sizes, and is thus potentially able to leverage vast knowledge bases or code repositories. How to make the best use of this capability is a topic for future work.
+
+# ACKNOWLEDGMENTS
+
+We want to thank Charles Staats for the many fruitful discussions and detailed comments, Henryk Michalewski for early version of of the memory implementation, Petros Maniatis for his help with our code datasets, Aitor Lewkowycz for his help with larger scale memorizing transformer experiments, Behnam Neyshabur for his comments on finetuning non-memory models, Imanol Schlag for his proofread and detailed comments, and Dennis Lee and Manzil Zaheer for discussions about large-scale attention and retrieval.
+
+# ETHICS
+
+The ability to memorize large databases of facts could have potential ramifications for society, especially if those databases include sensitive personal information or copyrighted works. However, one advantage of using an external memory is that the memory can be easily cleared of all such information, as we do at the end of each document that we train on. The same is not true of differentiable model parameters, which is what most existing architectures use to store facts and information that they are trained on.
+
+# REPRODUCIBILITY
+
+Details of our architecture and training hyperparameters are given in Section 4.2. The datasets for C4 and PG-19 are publicly available. Our additional datasets, Github, Isabelle, and ArXiv Math are derived from publicly available data buckets, which we link in the main part of the paper. Subsection 4.1 include details on how we constructed the datasets from those datasets. We plan to release our code as open source.
+
+# REFERENCES
+
+Joshua Ainslie, Santiago Ontañón, Chris Alberti, Vaclav Cvicek, Zachary Fisher, Philip Pham, Anirudh Ravula, Sumit Sanghai, Qifan Wang, and Li Yang. ETC: encoding long and structured inputs in transformers. In EMNLP, 2020.
+
+Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie J. Cai, Michael Terry, Quoc V. Le, and Charles Sutton. Program synthesis with large language models. CoRR, abs/2108.07732, 2021. URL https://arxiv.org/abs/ 2108.07732.
+
+Iz Beltagy, Matthew E. Peters, and Arman Cohan. Longformer: The long-document transformer. CoRR, abs/2004.05150, 2020. URL https://arxiv.org/abs/2004.05150.
+
+James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, George Necula, Adam Paszke, Jake VanderPlas, Skye Wanderman-Milne, and Qiao Zhang. JAX: composable transformations of Python+NumPy programs, 2018. URL http://github.com/google/jax.
+
+Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. In NeurIPS, 2020.
+
+Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harrison Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian, Clemens Winter, Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert-Voss, William Hebgen Guss, Alex Nichol, Alex Paino, Nikolas Tezak, Jie Tang, Igor Babuschkin, Suchir Balaji, Shantanu Jain, William Saunders, Christopher Hesse, Andrew N. Carr, Jan Leike, Joshua Achiam, Vedant Misra, Evan Morikawa, Alec Radford, Matthew Knight, Miles Brundage, Mira Murati, Katie Mayer, Peter Welinder, Bob McGrew, Dario Amodei, Sam McCandlish, Ilya Sutskever, and Wojciech Zaremba. Evaluating large language models trained on code. CoRR, abs/2107.03374, 2021. URL https://arxiv. org/abs/2107.03374.
+
+Krzysztof Marcin Choromanski, Valerii Likhosherstov, David Dohan, Xingyou Song, Andreea Gane, Tamás Sarlós, Peter Hawkins, Jared Quincy Davis, Afroz Mohiuddin, Lukasz Kaiser, David Benjamin Belanger, Lucy J. Colwell, and Adrian Weller. Rethinking attention with performers. In ICLR, 2021.
+
+Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems. CoRR, abs/2110.14168, 2021. URL https://arxiv.org/abs/2110.14168.
+
+Zihang Dai, Zhilin Yang, Yiming Yang, Jaime G. Carbonell, Quoc Viet Le, and Ruslan Salakhutdinov. Transformer-XL: Attentive language models beyond a fixed-length context. In ACL, 2019.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. In ACL, 2019.
+
+Angela Fan, Thibaut Lavril, Edouard Grave, Armand Joulin, and Sainbayar Sukhbaatar. Addressing some limitations of transformers with feedback memory. arXiv preprint arXiv:2002.09402, 2020.
+
+Angela Fan, Claire Gardent, Chloé Braud, and Antoine Bordes. Augmenting transformers with KNN-based composite memory for dialog. Transactions of the Association for Computational Linguistics, 9:82–99, 2021.
+
+Edouard Grave, Armand Joulin, and Nicolas Usunier. Improving neural language models with a continuous cache. In ICLR, 2017.
+
+Ruiqi Guo, Philip Sun, Erik Lindgren, Quan Geng, David Simcha, Felix Chern, and Sanjiv Kumar. Accelerating large-scale inference with anisotropic vector quantization. In ICML, 2020.
+
+Ankit Gupta, Guy Dar, Shaya Goodman, David Ciprut, and Jonathan Berant. Memory-efficient transformers via top- $\mathbf { \nabla } \cdot \mathbf { k }$ attention. CoRR, abs/2106.06899, 2021. URL https://arxiv.org/ abs/2106.06899.
+
+Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. Retrieval augmented language model pre-training. In ICML, 2020.
+
+Christopher Hahn, Frederik Schmitt, Jens U. Kreber, Markus Norman Rabe, and Bernd Finkbeiner. Teaching temporal logics to neural networks. In ICLR, 2021.
+
+Jonathan Heek, Anselm Levskaya, Avital Oliver, Marvin Ritter, Bertrand Rondepierre, Andreas Steiner, and Marc van Zee. Flax: A neural network library and ecosystem for JAX, 2020. URL http://github.com/google/flax.
+
+Alex Henry, Prudhvi Raj Dachapally, Shubham Shantaram Pawar, and Yuxuan Chen. Query-key normalization for transformers. In EMNLP, 2020.
+
+Jeff Johnson, Matthijs Douze, and Hervé Jégou. Billion-scale similarity search with GPUs. IEEE Transactions on Big Data, 2021.
+
+Urvashi Khandelwal, Omer Levy, Dan Jurafsky, Luke Zettlemoyer, and Mike Lewis. Generalization through memorization: Nearest neighbor language models. In ICLR, 2020.
+
+Nikita Kitaev, Łukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. In ICLR, 2020.
+
+Taku Kudo and John Richardson. Sentencepiece: A simple and language independent subword tokenizer and detokenizer for neural text processing. In EMNLP, 2018.
+
+Guillaume Lample, Alexandre Sablayrolles, Marc’Aurelio Ranzato, Ludovic Denoyer, and Hervé Jégou. Large memory layers with product keys. In NeurIPS, 2019.
+
+Mike Lewis, Marjan Ghazvininejad, Gargi Ghosh, Armen Aghajanyan, Sida Wang, and Luke Zettlemoyer. Pre-training via paraphrasing. In NeurIPS, 2020a.
+
+Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, et al. Retrieval-augmented generation for knowledge-intensive NLP tasks. In NeurIPS, 2020b.
+
+Wenda Li, Lei Yu, Yuhuai Wu, and Lawrence C. Paulson. Isarstep: a benchmark for high-level mathematical reasoning. In ICLR, 2021.
+
+Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, Thomas Hubert, Peter Choy, Cyprien de Masson d’Autume, Igor Babuschkin, Xinyun Chen, Po-Sen Huang, Johannes Welbl, Sven Gowal, Alexey Cherepanov, James Molloy, Daniel J. Mankowitz, Esme Sutherland Robson, Pushmeet Kohli, Nando de Freitas, Koray Kavukcuoglu, and Oriol Vinyals. Competition-level code generation with alphacode. DeepMind, 2022.
+
+Stanislas Polu and Ilya Sutskever. Generative language modeling for automated theorem proving. CoRR, abs/2009.03393, 2020. URL https://arxiv.org/abs/2009.03393.
+
+Markus Norman Rabe, Dennis Lee, Kshitij Bansal, and Christian Szegedy. Mathematical reasoning via self-supervised skip-tree training. In ICLR, 2021.
+
+Jack W Rae, Anna Potapenko, Siddhant M Jayakumar, Chloe Hillier, and Timothy P Lillicrap. Compressive transformers for long-range sequence modelling. In ICLR, 2020.
+
+Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 2020.
+
+Hongyu Ren, Hanjun Dai, Zihang Dai, Mengjiao Yang, Jure Leskovec, Dale Schuurmans, and Bo Dai. Combiner: Full attention transformer with sparse computation cost. CoRR, abs/2107.05768, 2021. URL https://arxiv.org/abs/2107.05768.
+
+Aurko Roy, Mohammad Saffar, Ashish Vaswani, and David Grangier. Efficient content-based sparse attention with routing transformers. Transactions of the Association for Computational Linguistics, 9:53–68, 2021.
+
+Noam Shazeer and Mitchell Stern. Adafactor: Adaptive learning rates with sublinear memory cost. In ICML, 2018.
+
+Sainbayar Sukhbaatar, Edouard Grave, Guillaume Lample, Herve Jegou, and Armand Joulin. Augmenting self-attention with persistent memory. arXiv preprint arXiv:1907.01470, 2019.
+
+Sainbayar Sukhbaatar, Da Ju, Spencer Poff, Stephen Roller, Arthur Szlam, Jason Weston, and Angela Fan. Not all memories are created equal: Learning to forget by expiring. In ICML, 2021.
+
+Simeng Sun, Kalpesh Krishna, Andrew Mattarella-Micke, and Mohit Iyyer. Do long-range language models actually use long-range context? In EMNLP, 2021.
+
+Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. arXiv preprint arXiv:2009.06732, 2020.
+
+Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena: A benchmark for efficient transformers. In ICLR, 2021.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017.
+
+Qingxiang Wang, Chad Brown, Cezary Kaliszyk, and Josef Urban. Exploration of neural machine translation in autoformalization of mathematics in mizar. In International Conference on Certified Programs and Proofs, 2020a.
+
+Sinong Wang, Belinda Z Li, Madian Khabsa, Han Fang, and Hao Ma. Linformer: Self-attention with linear complexity. arXiv preprint arXiv:2006.04768, 2020b.
+
+Xun Wang, Haozhi Zhang, Weilin Huang, and Matthew R. Scott. Cross-batch memory for embedding learning. In CVPR, 2020c.
+
+Ronald J. Williams and Jing Peng. An efficient gradient-based algorithm for on-line training of recurrent network trajectories. Neural Computation, 1990.
+
+Dani Yogatama, Cyprien de Masson d’Autume, and Lingpeng Kong. Adaptive semiparametric language models. ACL, 9:362–373, 2021.
+
+Manzil Zaheer, Guru Guruganesh, Kumar Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontañón, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, and Amr Ahmed. Big bird: Transformers for longer sequences. In NeurIPS, 2020.
+
+Yury Zemlyanskiy, Joshua Ainslie, Michiel de Jong, Philip Pham, Ilya Eckstein, and Fei Sha. Readtwice: Reading very large documents with memories. In ACL: Human Language Technologies, 2021.
+
+Zhenhai Zhu and Radu Soricut. H-transformer-1d: Fast one-dimensional hierarchical attention for sequences. In ACL, 2021.
+
+# A LENGTH OF INPUTS
+
+![](images/590dba826b536883dbd7b839ee67cfd0767b9162d302b75f3df6ce355c757fe0.jpg)
+
+Figure 9: Histogram of the number of tokens in arXiv math papers dataset. We tuncated the histogram at 500k tokens. The maximum paper had almost 1.6M tokens.
+
+![](images/392ac5da3e6f25f1ea04b96cb84fa3eff4102cd04a0f0ce5ff97fef8be49ba65.jpg)
+
+Figure 10: Histogram of the number of tokens in Github repositories dataset. We cut off the long tail of this plot. The repository with the maximum length has just over 9M tokens.
+
+![](images/869058a85d9ebbb8cb3aece05d5f6c75030dc1420ab9ed7ce7b5e7a8cff0cae2.jpg)  
+Figure 11: Histogram of the number of tokens in Isabelle proof scripts dataset.
+
+![](images/bdeca69f56f05a45e94288812872dd89cc33979dff117d6c86f428d2a5fc1362.jpg)  
+Figure 12: Histogram of the number of tokens in PG19 books dataset.
+
+![](images/049c1502062b0ef6c727e79a603400063a529317f7c6978f8199ef3811fadea6.jpg)  
+Figure 13: Histogram of the number of tokens in C4 documents filtered by documents that have less than 4096 tokens.
+
+# A.1 ABLATION STUDIES
+
+In the following section, we performed ablation studies to investigate the effects of various hyperparameters. Unless otherwise specified, we carried out these experiments with a memorizing transformer with context size 512, XL cache 512 with a memory size of 8192.
+
+Multiple $k \mathbf { N N }$ layers. We experimented with using two $k \mathbf { N N }$ layers, rather than just one. However, we did not see further benefits brought by more than multiple retrieval layers.
+
+$k \mathbf { N N }$ layer index We experimented with adding the external memory to layer 3, 6, 9 and 12 in a 12-layer transformer, with results shown in Table 14. We found that adding memory to the middle of the layer stack will obtain the best result, whereas adding memory to layers either too close to the input or to the output obtained less gains.
+
+Table 14: Different layer index.   
+
+<table><tr><td>Layer index</td><td>Perplexity</td></tr><tr><td>3</td><td>2.40</td></tr><tr><td>6</td><td>2.36</td></tr><tr><td>9</td><td>2.37</td></tr><tr><td>12</td><td>2.43</td></tr></table>
+
+Number of neighbors We studied the effects of the number of neighbors we retrieve from memory, with results shown in Table 15. We found that even with 32 number of neighbors, we can already obtain a comparable results with 128 or 256 neighbors.
+
+Table 15: Number of neighbors.   
+
+<table><tr><td>Number of neighbors</td><td>Perplexity</td></tr><tr><td>32</td><td>2.38</td></tr><tr><td>128</td><td>2.37</td></tr><tr><td>256</td><td>2.37</td></tr></table>
+
+Random seeds We measured the statistical significant of the results reported. We did 3 runs with 3 random seeds for Transformer XL of size 512, and also a memorizing transformer with memory size 8192. We measured the standard deviation of perplexities after 500K steps of training, shown in Table 16. We saw the standard deviation between different runs of the same experiment appears to be much smaller than the gap between different models.
+
+Table 16: Random seeds.   
+
+<table><tr><td>Models</td><td>Perplexity</td></tr><tr><td>Transformer XL</td><td>2.67± 0.01</td></tr><tr><td>Memorizing Transformer</td><td>2.37 ± 0.005</td></tr></table>
+
+B WHAT DOES THE MODEL RETRIEVE FROM MEMORY?
+
+Retrieving citation names On arXiv math, several examples are shown in Table 17, which includes both the retrieved token and its surrounding context. We observe that many of the gains in crossentropy loss took place when trying to predict the name of bibitems, citations, or references, by looking up the references and citations used previously in the paper. Such lookups usually span over the entire paper, which is much longer than 8192 tokens, providing a plausible explanation for the gain beyond memory size of 8192.
+
+Table 17: The table shows several examples of which tokens were retrieved during language modelling of arXiv math dataset. The model is retrieving names of the references from previous passages.   
+
+<table><tr><td>Query index1</td><td>Input</td><td></td><td>tTargetSurrounding context</td><td></td><td>Retrieved index Retrieved surrounding context</td></tr><tr><td>20389</td><td>Mon</td><td>thus</td><td>bibitem{ComtetMonthusYor</td><td>2208</td><td>Brownian motion \cite{ComtetMonthus Yor</td></tr><tr><td>16623</td><td>cha</td><td>kra</td><td>\cite{ chakrabarti)</td><td>4677</td><td>~1.2 of\cite{chakrabarti</td></tr><tr><td>14747</td><td>as</td><td>d</td><td>\eqref( asdfg ) }which</td><td>3365</td><td>begin{equation}\n \labelt asdfg</td></tr></table>
+
+Retrieving function names from the codebase As with the arXiv papers, we also studied which tokens the model retrieved from memory. As might be expected, the model is often looking up the names of functions, and variables, as shown in Table 18.
+
+Table 18: Examples of memory retrieval in the Github dataset. The model looks up how functions are used elsewhere in the repository.   
+
+<table><tr><td>Query index</td><td>Input</td><td></td><td>TargetSurrounding context</td><td></td><td>Retrieved indexRetrieved surrounding context</td></tr><tr><td>23837</td><td>Fo</td><td>nte</td><td>menu_play-&gt; setarFonte</td><td>14607</td><td>menu_load-&gt; setarFonte</td></tr><tr><td>23825</td><td>，</td><td>35</td><td>hscreen/2-50,50,200,35 )；</td><td>14599</td><td>20, y+40,200,35)</td></tr><tr><td>14546</td><td>-&gt;</td><td>adi</td><td>panel-&gt; adicionaComponente</td><td>5205</td><td>panel-&gt; adicionaComponente</td></tr></table>
+
+# B.1 MORE RETRIEVING EXAMPLES IN FORMAL THEOREM PROVING CORPU
+
+# Example 1
+
+• Input token index: 64604   
+• Input token: “_”   
+• Target token: “pair”   
+• Surrounding context: )) by (simp add: Fourier_sum_limit_pair [OF f, symmetric] Fourier’ • Name needs to be predicted: Fourier_sum_limit_pair   
+• Retrieved token: “Four”   
+• Retrieved token index: 64412   
+• Retrieved context: $2 ^ { \ast } { \mathfrak { n } }$ . Fourier_coefficient f k \* trigonometric_set k t)   
+• Definition of the name: lemma Fourier sum limit pair: assumes"f absolutely_integrable_on {-pi..pi}" shows"(入n. Ck<2 \*n. Fourier_coefficient f k \* trigonometric _set k t) 1 $\longleftrightarrow$ (入n. k<n.Fourier_coefficient f k \*trigonometric_setk t) 1" (is "?lhs $=$ ?rhs")
+
+# Example 2
+
+• Input token index: 46175   
+• Input token: “tri”’   
+• Target token: “gon”   
+• Surrounding context: <le>n. a k \* trigonometric_set k x) Name needs to be predicted: orthonormal_system_trigonometric_set Retrieved token: “gon”   
+• Retrieved token index: 35457   
+• Retrieved context: lemma orthonormal_system_trigonometric_set: $\backslash \mathrm { n }$ "orthonormal_system   
+• Definition of the name:
+
+![](images/83343cb6eed79c43cb0dd8e243d363d5ae700fb0872618464e56ae9135f177c1.jpg)  
+Figure 19: Definition of Fourier_sum_limit_pair.   
+Figure 20: Definition of orthonormal_system_trigonometric_set.
+
+# Example 3
+
+• Input token index: 49760   
+• Input token: “sum”’   
+• Target token: “m”   
+• Surrounding context: nusing Fourier_series_square_summable [OF assms, of’   
+• Name needs to be predicted: Fourier_series_square_summable   
+• Retrieved token: “sum”   
+• Retrieved token index: 35457   
+• Retrieved context: lemma Fourier_series_square_summable\n assumes:   
+• Definition of the name:
+
+Lemma Fourier series square summable: assumes os: "orthonormal_system $\textsf { S w } ^ { * }$ and w: "∧i. (w i) square_integrable S" and f: "f square integrable S" shows "summable (confine (λi. (orthonormal_coeff S w f i) $\sim 2$ ） I)"
+
+Figure 21: Definition of Fourier_series_square_summable.
+
+# Example 4
+
+• Input token index: 49697   
+• Input token: “_”’   
+• Target token: “system”   
+• Surrounding context: lemma Riemann_lebesgue_square_integrable: nassumes "orthonormal_system S w   
+• Name needs to be predicted: orthonormal_system   
+• Retrieved token: “system”   
+• Retrieved token index: 28052   
+• Retrieved context: definition orthonormal_system :: "\’a::euclidean’   
+• Definition of the name:
+
+definition orthonormal_system :: "'a::euclidean_space ${ \mathsf { s e t } } \Rightarrow ( ^ { \mathrm { ~ \iota ~ } } \mathsf { b } \Rightarrow ^ { \mathrm { ~ \iota ~ } } \mathsf { a } \Rightarrow \mathsf { r e a l } ) \Rightarrow \mathsf { b o o l } ^ { \mathrm { ~ \iota ~ } }$ where"orthonormal_system ${ \sf S } \ w \equiv \forall \mathfrak { m } \ \mathfrak { n }$ .l2product S (wm)(wn) $=$ (if m = n then 1 else 0)"
+
+# Example 5
+
+• Input token index: 34817   
+• Input token: “.”’   
+• Target token: “b”   
+• Surrounding context: shows "integrable (lebesgue_on {a..b})   
+• Retrieved token 1: “.”   
+• Retrieved token index 1: 2416   
+• Retrieved context 1: lebesgue_on {a..b}) f i   
+• Retrieved token 2: “-”   
+• Retrieved token index 2: 2445   
+• Retrieved context 2: (lebesgue_on {a-c..b-c}) (   
+• Retrieved token 3: “-”   
+• Retreived token index 3: 6479   
+• Retrieved context 3: (lebesgue_on {-pi..pi}) (
+
+# Example 6
+
+• Input token index: 49759   
+• Input token: “_”’   
+• Target token: “sum”   
+• Surrounding context: $0 " \backslash \mathtt { n }$ using Fourier_series_square_summable [OF assms   
+• Retrieved token 1: “set”   
+• Retrieved token index 1: 35044   
+• Retrieved context 1: definition trigonometric_set :: "nat \<Rightarrow>   
+• Retrieved token 2: “ier”   
+• Retrieved token index 2: 47272   
+• Retrieved context 2: definition Fourier_coefficient\nwhere   
+• Retrieved token 3: “ine”   
+• Retrieved token index 3: 18160   
+• Retrieved context 3: lemma Schwartz_inequality_strong:\nassumes “f’   
+• Retrieved token 4: “system”   
+• Retrieved token index 4: 28052   
+• Retrieved context 4: definition orthonormal_system :: “\’a::euclidean’   
+• Retrieved token 5: “<”   
+• Retrieved token index 5: 47241   
+• Retrieved context 5: subsection\<open>Convergence wrt the L’   
+• Retrieved token 6: “n”   
+• Retrieved token index 6: 40835   
+• Retrieved context 6: \n subsection\<open>A bit of extra’

parse/dev/TrjbxzRcnf-/TrjbxzRcnf-_content_list.json

@@ -0,0 +1,2127 @@
+[
+    {
+        "type": "text",
+        "text": "MEMORIZING TRANSFORMERS ",
+        "text_level": 1,
+        "bbox": [
+            312,
+            113,
+            684,
+            135
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yuhuai Wu, Markus N. Rabe, DeLesley Hutchins, Christian Szegedy ",
+        "bbox": [
+            274,
+            164,
+            723,
+            179
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{yuhuai,mrabe,delesley,szegedy}@google.com ",
+        "bbox": [
+            294,
+            193,
+            704,
+            205
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            246,
+            544,
+            262
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Language models typically need to be trained or finetuned in order to acquire new knowledge, which involves updating their weights. We instead envision language models that can simply read and memorize new data at inference time, thus acquiring new knowledge immediately. In this work, we extend language models with the ability to memorize the internal representations of past inputs. We demonstrate that an approximate $k \\mathbf { N N }$ lookup into a non-differentiable memory of recent (key, value) pairs improves language modeling across various benchmarks and tasks, including generic webtext (C4), math papers (arXiv), books (PG-19), code (Github), as well as formal theorems (Isabelle). We show that the performance steadily improves when we increase the size of memory up to 262K tokens. On benchmarks including code and mathematics, we find that the model is capable of making use of newly defined functions and theorems during test time. ",
+        "bbox": [
+            233,
+            279,
+            766,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            336,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Transformers (Vaswani et al., 2017) have led to remarkable progress in natural language processing (Devlin et al., 2019; Brown et al., 2020), mathematical reasoning (Polu & Sutskever, 2020; Wang et al., 2020a; Rabe et al., 2021; Li et al., 2021; Hahn et al., 2021; Cobbe et al., 2021), and program synthesis (Austin et al., 2021; Chen et al., 2021; Li et al., 2022). However, transformer performance on many of these tasks is limited by the context length of attention, which is typically short. The ability to attend to far-away tokens is important in many situations. In novels, characters and events are referenced across multiple chapters. In source code, references to classes and functions may occur quite far from the places in which they are defined. In theorem proving, proofs make use of previously defined lemmas. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            631
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Attention over long sequences is also useful as a form of rapid learning. Facts and information which are stored in the form of weight matrices must be slowly trained over hundreds of thousands of training steps. By using attention, however, a model can simply memorize facts (e.g. function definitions) by storing them as (key, value) pairs in long-term memory, and then retrieve those facts later by creating a query that attends to them. In this case, attention acts as a form of information retrieval, allowing the model to look up facts that it has seen previously. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            720
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate that a simple and effective way to increase the size of the attention context is to use approximate $k$ -nearest-neighbor $( k \\mathsf { N N } )$ lookup, which is widely used in information retrieval. A number of extremely scalable implementations of $k \\mathbf { N N }$ lookup are available, such as ScaNN (Guo et al., 2020) and Faiss (Johnson et al., 2021). ",
+        "bbox": [
+            174,
+            728,
+            825,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are two things which distinguish our approach from previous work on long-range attention (c.f. Section 2). First, unlike some other approaches, $k \\mathbf { N N }$ lookup does not do averaging or summarization of tokens at long distances, but retrieves exact values even from the distant context. ",
+        "bbox": [
+            176,
+            791,
+            823,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Second, gradients are not backpropagated into the external memory, which is critical to the scalability of our technique. The keys and values are a function of model parameters, so attempting to backpropagate gradients into external memory would necessarily involve computing all of the keys and values with the current model parameters on every training step. However, if the external memory is not differentiable, then we can instead instead reuse keys and values that were previously computed on prior training steps, which drastically reduces the amount of computation for large memories. With our technique, we are easily able to scale external memory up to sequence lengths of 131k or 262k tokens on a single TPU device, while maintaining a reasonable step time. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c348262572039ee17a0180d1f12a1ab33318f7e59c45735bf4ae47b93ca7fd68.jpg",
+        "image_caption": [
+            "Figure 1: Adding a memory of 8K tokens improves perplexity across different model sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            346,
+            103,
+            648,
+            247
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            291,
+            823,
+            319
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We show that model perplexity steadily improves with the size of external memory on a variety of language modelling tasks, including C4 (long documents only), Github code repositories, PG-19 books, formal proofs in Isabelle, and arXiv math papers. We further show that models can generalize to larger memory sizes than they were trained on: models trained with a small memory show gains from using a much larger memory at inference time. Finally, we show that our models are actually using memory in the way that we had hoped, e.g. by looking up the definitions of lemmas in a theorem proving corpus. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            424
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The simplicity of the changes to the Transformer architecture allows us to easily integrate this approach into existing code bases, including extremely large language models. We further show that the improvements to quality are maintained across models of increasing size, and that the model improvements gained from adding memory are even larger than increasing the size of the model by 5X or more as shown in Figure 1. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            343,
+            542
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A great deal of work has been done on efficient long-range attention mechanisms; see Tay et al. (2020; 2021) recent surveys. Sliding windows (Beltagy et al., 2020) use a long sequence, but attend within a smaller window, thus reducing complexity to the window size, rather than total sequence length. Approximate mechanisms such as Linformer (Wang et al., 2020b), and Performer (Choromanski et al., 2021) refactor the attention matrix by using a different kernel than softmax to obtain $O ( N )$ complexity. Pooling strategies such as Hierarchical 1D attention (Zhu & Soricut, 2021), and Combiner (Ren et al., 2021) apply pooling or averaging over tokens at longer distances. Sparse strategies such as Big Bird (Zaheer et al., 2020) select only a subset of tokens to attend to; Routing Transformers (Roy et al., 2021) use clustering to select the subset, while Reformer (Kitaev et al., 2020) relies on hashing. Hierarchical mechanisms (Ainslie et al., 2020) combine multiple tokens into phrases or sentences to reduce sequence length. Expire-span (Sukhbaatar et al., 2021) prunes far-away tokens that it learns are “unimportant”. (Zemlyanskiy et al., 2021) process long sequences in two passes with different encoders. The second pass is given a lot of context by accessing summaries of the first pass. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Feedback transformers (Fan et al., 2020) use a recurrent architecture in which each token attends to the output of the final layer instead of the previous layer. Recurrence does not increase the size of the attention context itself, but it expands the receptive field at the cost of parallelism and training speed. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Truncated backpropagation through time (Williams & Peng, 1990) was originally introduced as a way of training recurrent neural networks (RNN) over very long sequences, when the entire sequence does not fit in memory. The sequence is chopped into segments, and after each training step, the final RNN state for the segment is saved in a non-differentiable cache, and used as the initial state on the next training step. Neural caches (Grave et al., 2017) extend the cache to contain a record of many prior hidden states, and attend over them. Transformer-XL (Dai et al., 2019) applies this technique to transformers; it caches the (key,value) pairs computed from the previous training step, and uses them as a prefix for the tokens on the next training step, which yields significant gains on long documents. Rae et al. (2020) improve over Transformer-XL by compressing the tokens before adding them to the cache. In contrast, we use a very large cache without compression, combined with an approximate $k \\mathbf { N N }$ attention mechanism over it. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/93d8466b573b5325cd9a069c63eddcdd2572eb8799f9d4720b8a3dbfc7a46115.jpg",
+        "image_caption": [
+            "Figure 2: We extend Transformers with access to (key, value) pairs of previously seen subsequences. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            94,
+            735,
+            330
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            359,
+            823,
+            387
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Sukhbaatar et al. (2019) make the observation that the feed-forward portion of a transformer layer functions very much like attention if one replaces the ReLU activation with softmax. They implement a combined attention over both tokens from the input sequence and a learned (and differentiable) “memory”. Lample et al. (2019) exploit this observation to replace the feed-forward layers (FFNs) with a fast $k \\mathbf { N N }$ lookup over a much larger “memory”, and achieve large gains in model accuracy without significant computation overhead. (We use $k \\mathbf { N N }$ lookup to approximate attention to previous tokens, not to replace the FFN.) ",
+        "bbox": [
+            173,
+            395,
+            825,
+            492
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Non-differentiable external memory has been used in different ways by Khandelwal et al. (2020), who run a pre-trained model over an entire corpus, and construct a large table of (key, token) pairs. They then use that table to replace the final softmax layer for token selection in the model, which results in significant improvements in language modeling. Yogatama et al. (2021) extend this approach by a gating mechanism and a process to compress the context into keys for retrieval. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are several works that combine retrieval with transformers. REALM (Guu et al., 2020), MARGE (Lewis et al., 2020a), RAG (Lewis et al., 2020b), and composite memory for dialog (Fan et al., 2021) retrieve documents from a knowledge base to improve question answering or dialogue. The knowledge base consists of text snippets and is static and typically separate from the inputs and outputs of the models. Instead, we focus on language modeling using a decoder-only model, and propose a simple model that unifies attention and retrieval. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            660
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$k$ -nearest-neighbor lookup is a general-purpose technique that is used for a wide variety of machine learning and retrieval tasks, and high-performance implementations are available for various architectures (Johnson et al., 2021; Guo et al., 2020). Memory-efficient Transformers (Gupta et al., 2021) replace dense attention with a $k \\mathbf { N N }$ lookup to increase speed and reduce memory usage. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            723
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            744,
+            281,
+            761
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The architecture of our $k \\mathbf { N N }$ -augmented transformer is shown in Figure 2. The bulk of the model is a vanilla, decoder-only transformer (Vaswani et al., 2017). The input text is tokenized, and the tokens are embedded into vector space. The embedding vectors are passed through a series of transformer layers, each of which does dense self-attention, followed by a feed-forward network (FFN). Since this is a decoder-only language model, we use a causal attention mask and the token embeddings of the last layer are used to predict the next token. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Long documents are split into subsequences of 512 tokens, and each subsequence is used as the input for one training step. In contrast to standard practice, we do not shuffle the subsequences; instead, each long document is fed into the transformer sequentially, from beginning to end, as is done with Transformer-XL (Dai et al., 2019). ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/81f98de49b0afcae04d1631ab7e72f49483236312e44999b1680cfebdad0dc90.jpg",
+        "image_caption": [
+            "Figure 3: Our data pipeline splits documents into subsequences and packs subsequences into batches. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            92,
+            710,
+            150
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We also use a Transformer-XL style cache, which holds the keys and values from the previous training step. When doing self-attention, the cached keys and values are prepended to the current keys and values, and we use a sliding-window causal mask (Beltagy et al., 2020) so that each token has a local context that includes the previous 512 tokens. ",
+        "bbox": [
+            174,
+            178,
+            825,
+            234
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 $k$ NN-AUGMENTED ATTENTION LAYER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            252,
+            482,
+            266
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One of the transformer layers near the top of the stack is a kNN-augmented attention layer, which combines two forms of attention. Like all of the other layers, it uses standard dense self-attention on the local context, which is the input subsequence for the current training step. Unlike the other layers, however, it also does an approximate $k$ -nearest-neighbor search into the external memory. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            333
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The same queries are used for both the local context, and for the external memory. The keys and values also belong to the same distribution; after each training step, the (key, value) pairs in the local context are appended to the end of the external memory. If the document is very long, old (key, value) pairs will be dropped from the memory to make room for new ones. Thus, for each head, the external memory keeps a cache of the prior $M$ (key, value) pairs, where $M$ is the memory size. ",
+        "bbox": [
+            174,
+            340,
+            825,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The $k \\mathbf { N N }$ lookup will return a set of retrieved memories, which consist of the top- $k$ (key, value) pairs that $k \\mathbf { N N }$ search returns for each query (i.e. each token) in the input subsequence. As with standard dense attention, we first construct an attention matrix by computing the dot product of each query against the retrieved keys, then apply softmax, and finally return a weighted sum of the retrieved values. Unlike standard dense attention, the retrieved memories contain a different set of (key, value) pairs for each query. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            501
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Attention over the local context is performed in the usual way. The results of $k \\mathbf { N N }$ -attention and local attention are then combined using a learned gate: ",
+        "bbox": [
+            176,
+            507,
+            820,
+            536
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bcc1a414349765bb66cda899232d5a3a652a7eeca3407bcadf71361b09e36cd0.jpg",
+        "text": "$$\n\\begin{array} { c } { { g = \\sigma ( b _ { g } ) } } \\\\ { { V _ { a } = V _ { m } \\odot g + V _ { c } \\odot ( 1 - g ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            551,
+            601,
+            590
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma$ is the sigmoid function, and $\\odot$ is element-wise multiplication. $V _ { a }$ is the combined result of attention, $V _ { m }$ is the result of attending to external memory, and $V _ { c }$ is the result of attending to the local context. The bias $b _ { g }$ is a learned per-head scalar parameter, which allows each head to choose between local and long-range attention. In our experiments, the value of the gate $g$ does not depend on the content of the token at each position, although that would be a trivial extension to implement. We did observe that over time, most heads learned to attend almost exclusively to external memory. ",
+        "bbox": [
+            173,
+            601,
+            825,
+            685
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Position bias. For dense attention within the local context, we use the T5 relative position bias (Raffel et al., 2020). As noted by Dai et al. (2019), adding a global position encoding to each token does not work well when processing long documents. We don’t use a position bias for the retrieved memories. Experiments on the PG19 dataset (Sun et al., 2021) have shown that relative position does not appear to matter at long range, and the T5 relative bias puts all long-range tokens in the same bucket anyway. ",
+        "bbox": [
+            174,
+            691,
+            825,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Batching. Figure 3 illustrates how multiple long documents of different lengths are packed into a batch, and split into subsequences. Each subsequence in the batch comes from a different document, and thus requires a separate external memory, which is cleared at the start of each new document. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            810
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 DISTRIBUTIONAL SHIFT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            382,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Because each long document is processed over multiple training steps, there is a distributional shift in the keys and values that are stored in external memory. The model parameters that produce the queries change over time, and will thus have shifted since the keys and values were stored. For very large memories, older records may become “stale.” Similar observations have been made for CrossBatch memory (Wang et al., 2020c) in the vision domain. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To reduce the effects of staleness, we normalize keys and queries (Henry et al., 2020). Normalization does not eliminate staleness, but it at least ensures that older keys and newer keys do not differ in magnitude. We also found that normalization helps stabilize training with the Transformer-XL cache. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In some of our experiments, we observed that training models from scratch with a large memory sometimes resulted in worse performance than pretraining the model with a small memory of size 8192, and then finetuning it on a larger memory. This training instability could be due to staleness. However, models seem to be able to cope with a limited degree of staleness (with the small memory) by adjusting their queries accordingly. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            223
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 APPROXIMATE $k \\mathbf { N N }$ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            241,
+            354,
+            255
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We employ approximate $k \\mathbf { N N }$ search rather than exact $k \\mathbf { N N }$ search because it significantly improves the computational speed of our model. We use a simple approximation of $k \\mathbf { N N }$ for TPUs, which has a recall of about $90 \\%$ , i.e. $90 \\%$ of the true top $k$ are returned in the approximate top $k$ . There are various other efficient approximate $k \\mathbf { N N }$ algorithms available for CPU and GPU/TPU, for example through Faiss (Johnson et al., 2021) or ScaNN (Guo et al., 2020), which can scale into the billions. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            337
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            326,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the effect of adding external memory on five language modeling tasks, all of which involve long-form text: English language books (PG-19), long web articles (C4), technical math papers (arXiv Math), source code (Github), and formal theorems (Isabelle). The results show significant improvements in the perplexity of the model with the addition of external memory. We experimented with various sizes of external memory, from 1536 to as high as 262K. On most of the datasets, there was an initial sharp gain from adding a small external memory, followed by smaller but steadily increasing gains as the size of the memory was increased. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            488
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            506,
+            287,
+            521
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "arXiv Math For the arXiv dataset, we collected a corpus of papers by downloading them via the arXiv Bulk Data Access1. We filtered papers to include only articles labeled as “Mathematics” and whose $\\mathrm { I A T } \\mathrm { E } ^ { \\mathrm { X } }$ source was available. The number of tokens per paper in this dataset is roughly comparable to the number of tokens per book in PG19, because $\\mathrm { I A T } \\mathrm { E } ^ { \\mathrm { X } }$ source has many special characters and the tokenizer tends to output small subwords. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            603
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Github We used BigQuery2 to obtain a large corpus of Github repositories that are published with open-source licenses. We used file endings to filter for files in the languages C, $\\mathrm { C } { + + }$ , Java, Python (including Jupyter notebooks), Go, and TypeScript. Individual source code files are often fairly short, and there are many dependencies and cross-references between files in the repository. To capture these dependencies, we created one long document for each Github repository by traversing the directory tree, and concatenating all of the files within it. The order in which files are traversed within the repository is random, but each subdirectory is processed as a unit, so that all the files within the subdirectory are close to each other in the resulting document. Source code is usually structured so that related files are all grouped together in the same subdirectory; this traversal preserves that structure, while still shuffling files and subdirectories in random order. ",
+        "bbox": [
+            174,
+            618,
+            825,
+            758
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Formal Math – Isabelle The Isabelle corpus consists of formal mathematical proofs of theories. We collected all 627 theories available on The Archive of Formal Proofs3 (as of October 6, 2021) and an additional 57 theories from the Isabelle standard library4 to create a corpus of 684 theories. All theories have open-source licenses. Each theory is a self-contained mathematical object, on topics such as foundational logic, advanced analysis, algebra, or cryptography, and consists of multiple files containing proofs. As with the Github corpus, all files that make up a theory are concatenated together into one long document. Unlike the Github corpus, we order the files according to their import dependencies, so that later files use sub-theorems that are proved in earlier files. ",
+        "bbox": [
+            176,
+            775,
+            823,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/ba860c228ba1df8e0970d8053efe9bf7be4795e38980d72a5c422fe74f7d4358.jpg",
+        "table_caption": [
+            "Table 4: Average token-level perplexities of each model when trained for 500k steps. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Context</td><td>Memory</td><td>XL cache</td><td>arXiv</td><td>PG19</td><td>C4(4K+)</td><td>GitHub</td><td>Isabelle</td></tr><tr><td>512</td><td>None</td><td>None</td><td>3.29</td><td>13.71</td><td>17.20</td><td>3.05</td><td>3.09</td></tr><tr><td>2048</td><td>None</td><td>None</td><td>2.69</td><td>12.37</td><td>14.81</td><td>2.22</td><td>2.39</td></tr><tr><td>512</td><td>None</td><td>512</td><td>2.67</td><td>12.34</td><td>15.38</td><td>2.26</td><td>2.46</td></tr><tr><td>2048</td><td>None</td><td>2048</td><td>2.42</td><td>11.88</td><td>14.03</td><td>2.10</td><td>2.16</td></tr><tr><td>512</td><td>1536</td><td>None</td><td>2.61</td><td>12.50</td><td>14.97</td><td>2.20</td><td>2.33</td></tr><tr><td>512</td><td>8192</td><td>None</td><td>2.49</td><td>12.29</td><td>14.42</td><td>2.09</td><td>2.19</td></tr><tr><td>512</td><td>8192</td><td>512</td><td>2.37</td><td>11.93</td><td>14.04</td><td>2.03</td><td>2.08</td></tr><tr><td>512</td><td>65K</td><td>512</td><td>2.31</td><td>11.62</td><td>14.04</td><td>1.87</td><td>2.06</td></tr><tr><td>2048</td><td>8192</td><td>2048</td><td>2.33</td><td>11.84</td><td>13.80</td><td>1.98</td><td>2.06</td></tr><tr><td>2048</td><td>65K</td><td>2048</td><td>2.26</td><td>11.37</td><td>13.64</td><td>1.80</td><td>1.99</td></tr></table>",
+        "bbox": [
+            240,
+            101,
+            756,
+            276
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            316,
+            823,
+            345
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { C 4 } ( 4 \\mathbf { K } + )$ C4, the colossal cleaned common crawl, is a very large collection of documents that have been scraped from the internet (Raffel et al., 2020). We filtered out all documents that have less than 4096 tokens to focus on documents where memory can have an impact. ",
+        "bbox": [
+            174,
+            362,
+            823,
+            404
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "PG-19 PG-19 is a large dataset of English-language books, published prior to 1919, which were retrieved from the Project Gutenberg archive (Rae et al., 2020; Sun et al., 2021). PG-19 is one of the few public datasets that only contains full-length books, and has become a benchmark for long-range natural language text modeling. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTAL METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            393,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We used a 12-layer decoder-only transformer (with and without Transformer-XL cache) with an embedding size of 1024, 8 attention heads of dimension 128, and an FFN hidden layer of size 4096. For all of our experiments, we used $k = 3 2$ . Unless specified otherwise, we use the 9th layer as the $k \\mathbf { N N }$ augmented attention layer. We used a sentence-piece (Kudo & Richardson, 2018) tokenizer with a vocabulary size of 32K. ",
+        "bbox": [
+            174,
+            522,
+            825,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We used the Adafactor optimizer (Shazeer & Stern, 2018). In preliminary experiments, we conducted a hyperparameter search to determine the optimal learning rate among three choices ({3.0, 1.0, $3 \\cdot { \\bar { 1 0 } } ^ { - 1 } \\}$ ), and found that 1.0 works best. We used a linear warmup schedule for the first 1000 steps, followed by square root decay. We trained the models from scratch for 500K steps on all the datasets, except for the Isabelle dataset. Isabelle is small, so we stopped training after 100K steps when the model began to overfit. We ran all of our experiments on 32 TPU cores. Our models were implemented in JAX (Bradbury et al., 2018) and Flax (Heek et al., 2020). ",
+        "bbox": [
+            173,
+            598,
+            825,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When comparing models with different context lengths, we adjusted the batch size (the number of documents in a batch) so that there are always $2 ^ { 1 7 }$ tokens in a batch. E.g., a model with a context length of 512 has a batch size of 256, while the 2048 model has a batch size of 64. ",
+        "bbox": [
+            176,
+            704,
+            821,
+            746
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We experimented with multiple implementations of approximate $k \\mathbf { N N }$ lookup with different tradeoffs between quality and computational cost. We did not observe a significant degradation of the model quality when switching to lower quality approximations of $k \\mathbf { N N }$ , so the model appears to be quite robust with respect to the quality of $k \\mathbf { N N }$ retrieval. For a model with around 200M trainable parameters the step time increased from 0.2s to $0 . 2 5 \\mathrm { s }$ when we added a memory of size 8K, and to 0.6s when we added a memory of size 65K (measured on TPUv3). ",
+        "bbox": [
+            174,
+            752,
+            825,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 EFFECT OF EXTERNAL MEMORY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            434,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Adding external memory results in substantial gains across datasets and architectures, as shown in Table 4. Across all five datasets, adding external memory to either the vanilla Transformer or the Transformer-XL architecture improves perplexity by a substantial amount. For example, on $\\mathrm { C 4 } ( 4 \\mathrm { K } + )$ dataset, adding memory of size 8192 improves the perplexity of the vanilla Transformer (with context size 512) from 17.20 to 14.42, and improves Transformer-XL from 15.38 to 14.04. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/4782106695f92ea320beb22a6928adcb6fa0132108ecbecfc4a6af020e3ce2b3.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 5: Finetuning for 20K steps to make use of a larger memory on the arXiv data set. "
+        ],
+        "table_body": "<table><tr><td>Context</td><td>Pretrain</td><td>Fine-tune</td><td>Perplexity</td></tr><tr><td>512</td><td>8192</td><td>None</td><td>2.37</td></tr><tr><td>512</td><td>65K</td><td>None</td><td>2.31</td></tr><tr><td>512</td><td>8192</td><td>65K</td><td>2.32</td></tr><tr><td>512</td><td>8192</td><td>131K</td><td>2.30</td></tr><tr><td>512</td><td>8192</td><td>262K</td><td>2.26</td></tr><tr><td>2048</td><td>8192</td><td>None</td><td>2.33</td></tr><tr><td>2048</td><td>65K</td><td>None</td><td>2.26</td></tr><tr><td>2048</td><td>65K</td><td>131K</td><td>2.23</td></tr><tr><td>2048</td><td>65K</td><td>262K</td><td>2.21</td></tr></table>",
+        "bbox": [
+            341,
+            99,
+            655,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            309,
+            826,
+            338
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Increasing the size of the memory increases the benefit of the memory. The best perplexities for all datasets and architectures were obtained with a memory size of 65K. ",
+        "bbox": [
+            173,
+            356,
+            823,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Note that Transformer-XL with context size 2048 already has a theoretical receptive field that is quite large. Each token in a higher layer can attend up to 2048 tokens away in the layer below, so the total receptive field is $2 0 4 8 \\cdot 1 2$ (layers) $\\sim 2 5 \\mathrm { K }$ . Nevertheless, we still saw a substantial gain when adding an external memory of size 8192 to this model. $k \\mathbf { N N }$ attention into memory would appear to be a more effective way to retrieve information from the distant past than the Transformer-XL cache. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, we also saw improvements by adding XL cache to the large-memory (65K) models. In a vanilla (non-XL) Transformer, the first few tokens in a sequence have very little context, and thus have higher perplexity. The XL cache provides additional local short-range context at the start of a sequence, which complements the long-range context provided by external memory. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, in a vanilla Transformer, using even a small external memory of size 1536 provides a gain in perplexity which is almost as good as using a local context of size 2048 but no memory (e.g. Table 4). This is surprising, because the external memory is not differentiable, and is added only to one layer of the Transformer, whereas increasing the context size is differentiable and affects all layers. We conclude that the lower layers of a Transformer don’t necessarily need long-range context, and having a differentiable memory is not as important as one might suspect. ",
+        "bbox": [
+            174,
+            530,
+            825,
+            614
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 SCALING TO LARGER MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            633,
+            423,
+            647
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We scaled up the Transformer model to sizes of 1 and 8 billion parameters. For the 1 billion parameter model, we use 8 layers, 32 heads with head dimension 128, $d _ { - }$ model 2048, and $d _ { - }$ _ff 16384. For the 8 billion parameter model, we use 64 heads, 16 layers, $d$ _model 4096, and $d _ { - }$ _ff 32768. We used a context size of 2048, memory size of 8192, and no XL cache. We ran the comparisons to the vanilla Transformer on the arXiv math dataset. Scaling plots are shown in Figure 1. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            731
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "External memory provides a consistent improvement to the model as it is scaled up. Remarkably, we found that the smaller Memorizing Transformer with just 8k tokens in memory can match the perplexity of a larger vanilla Transformer which has 5X more trainable parameters. ",
+        "bbox": [
+            176,
+            737,
+            825,
+            780
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.5 FINETUNING ON LARGER MEMORIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            799,
+            472,
+            813
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Finetuning on a larger memory. In some cases, training was unstable when using large memories, possibly due to distributional shift early in the training (See Section 3.2). Thus, for memories of 131K or more tokens, we first pretrain the model with a memory size of 8192 or 65K for 500K steps, and then finetune it with the larger memory for an additional 20K steps. The results of finetuning on the arXiv Math data set are shown in Table 5. Increasing the size of external memory provided consistent gains up to a size of 262K. Note that 262K tokens is longer than almost all of the documents in arXiv, and thus we would not expect to see any gain past this point (see Appendix A). ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/14d1bef481a2ec3931ed59a899d428ebe8a68caed797c0d03c05a6ce7c996ad0.jpg",
+        "image_caption": [
+            "Figure 6: Finetuning a 1B vanilla Transformer model to use external memory of size 65K. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            348,
+            104,
+            647,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finetuning a non-memory model to use memory Pretraining can be very costly both in time and computational resources. Thus, a natural question to ask is: can one fine-tune a pretrained Transformer to use external memory? The answer is yes! ",
+        "bbox": [
+            176,
+            328,
+            823,
+            369
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We took a pre-trained 1B vanilla Transformer model, and fine-tuned it to use external memory (the 1B models used in Section 4.4). The fine-tuning result is shown in Figure 6. Notice that the model quickly learns to use external memory. Within 20K steps $4 \\%$ of the pre-training time) the fine-tuned model has already closed $8 5 \\%$ of the gap between it and the 1B Memorizing Transformer, and after $1 0 0 \\mathrm { k }$ steps it has closed the gap entirely. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            446
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.6 INFORMATION RETRIEVAL PATTERNS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            469,
+            473,
+            483
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We conducted a qualitative study of what the model was actually retrieving from external memory, by finding which tokens showed the biggest improvements in cross-entropy loss when the size of the memory was increased, and then examining the top- $k$ retrieved memories for those tokens. We found that the model gained the most when looking up rare words, such as proper names, references, citations, and function names, where the first use of a name is too far away from subsequent uses to fit in the local context. This result is in keeping with the prior analysis of long-context Transformers on PG19 (Sun et al., 2021), which found similar lookup patterns. For this experiment, we used a slightly older version of the architecture without the gating mechanism. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            609
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Which tokens show a benefit from memory? Figure 7 shows a visualization of which tokens show an improvement when the size of the external memory is increased. We selected a math paper at random, and plotted the difference in cross entropy loss for each token $x _ { i }$ in the paper, comparing two models with the same parameters, but with memories of different sizes. $\\Delta _ { i } = \\mathrm { c r o s s - e n t r o p y } _ { 8 1 9 2 } ( x _ { i } )$ $- \\mathrm { c r o s s - e n t r o p y } _ { 3 2 \\mathrm { K } } ( x _ { i } )$ . Positive values show an improvement in loss. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The $x$ -axis on the chart is the token number $i$ , while the $y$ -axis is $\\Delta _ { i }$ . For the first 8192 tokens, the difference between the two models is zero, since the larger capacity of the 32K memory isn’t being used yet. However, after token 8193, we can see that the larger memory helps, on average, over the smaller memory. The benefit is not universal, since the predictions for some tokens become worse, possibly due to the fact that a relevant retrieved memory no longer makes it into the top- $k$ when the size of the external memory is increased. This figure also shows that the benefit of external memory is somewhat sparse. The improvement in perplexity seems to be mainly driven by a small percentage of tokens that obtain a large improvement in cross-entropy loss when using the larger memory. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "What information is being looked up? Given that only a subset of tokens shows improvement from external memory, we did a further investigation into what, exactly, those tokens are using the memory for. We took those tokens which showed the largest improvement in cross-entropy loss, and for each of them tokens, we examined the top- $k$ retrieved memories. We studied arXiv math, Github and Isabelle corpus. For arXiv math and Github, we found the model retrieved function and variable names. See more details with examples in Appendix B. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/ac7dcbfadeffdce1e7c62204b4feff0227f84bf9079091c5be4d5700f286a668.jpg",
+        "image_caption": [
+            "Figure 7: Difference in loss for each token in a randomly chosen paper, using the same model once with a memory size of 8K and once with 32K. Higher numbers mean the longer memory helped in comparison to the shorter memory. This paper is 22K tokens long. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            92,
+            792,
+            161
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/4cf585def3b67985c0413709b5970581b404b2a5f9e8e8dcb838c1acadc6ca0b.jpg",
+        "table_caption": [
+            "Table 8: Examples of memory retrieval in the Isabelle dataset. The model is able to find the definition of a lemma from a reference to it. The retrieved surrounding context (highlighted) is the definition body of the mathematical object highlighted in the querying context. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td></td><td>Query indexInputTargetSurrounding context</td><td></td><td>Retrieved index Retrieved surrounding context</td></tr><tr><td>29721</td><td>mark</td><td>ov</td><td>rule prob_space. markov_inequality</td><td>8088</td><td>M.t\\&lt;le&gt; X a} \\&lt;le&gt; expectation X /t&quot;</td></tr><tr><td>40919</td><td>1</td><td>th</td><td>= ( subgraph_threshold Hn / p n)</td><td>27219</td><td>threshold H n = n powr (-(1 / max_density’</td></tr><tr><td>49699</td><td>S</td><td>W</td><td>assumes&#x27; orthonormal_system Sw&quot;</td><td>28050</td><td>definition orthonormal_system “</td></tr></table>",
+        "bbox": [
+            174,
+            231,
+            823,
+            295
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Retrieving mathematical definitions. Our case study on the Isabelle corpus provides one of the clearest illustrations of how a model can make good use of external memory. When predicting the name of a mathematical object or a lemma, the model looked up the definition from earlier in the proof. Examples of this behavior are shown in Table 8. In example 1, the model retrieves a definition within the body of a lemma, markov_inequality. In example 2, it retrieves the definition of a previously defined concept subgraph_threshold. In example 3, it retrieves the definition of orthonormal_system. We manually checked 10 examples where the model made a prediction of lemma names, and 8 out of 10 times model found the body of the lemma it needs to predict. In the other two cases, the model also looked up materials in the immediate vicinity. To the best of our knowledge, this is the first demonstration that attention is capable of looking up definitions and function bodies from a large corpus. The Isabelle case study used a model with two memory layers of size 32K. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            545,
+            318,
+            561
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We present a simple extension to the Transformer architecture, called kNN-augmented attention, which dramatically increases the length of the context that a language model can attend to by using $k$ -nearest-neighbor lookup into a large external memory. We demonstrate the effectiveness of external memory in a series of language modeling experiments over a variety of long-document datasets, including LaTeX documents, source code, formal proofs, and books. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            647
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The Memorizing Transformer shows large improvements in perplexity over the baseline for all of the data sets and architectures that we studied; it is comparable to a vanilla transformer that has 5 times the number of parameters. Perplexity continues to improve with increasing memory size, although there is a point of diminishing returns. Moreover, external memory continues to provide benefits even as the transformer is scaled up from 200M to 8B parameters. Perhaps most intriguingly, a Memorizing Transformer does not need to be pre-trained from scratch; it is possible obtain large gains from adding memory to an existing pre-trained model, and then fine-tuning it. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            751
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Unlike other forms of attention, $k \\mathbf { N N }$ retrieval can be easily scaled up to huge memory sizes, and is thus potentially able to leverage vast knowledge bases or code repositories. How to make the best use of this capability is a topic for future work. ",
+        "bbox": [
+            176,
+            758,
+            823,
+            800
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            816,
+            326,
+            829
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We want to thank Charles Staats for the many fruitful discussions and detailed comments, Henryk Michalewski for early version of of the memory implementation, Petros Maniatis for his help with our code datasets, Aitor Lewkowycz for his help with larger scale memorizing transformer experiments, Behnam Neyshabur for his comments on finetuning non-memory models, Imanol Schlag for his proofread and detailed comments, and Dennis Lee and Manzil Zaheer for discussions about large-scale attention and retrieval. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ETHICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            238,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The ability to memorize large databases of facts could have potential ramifications for society, especially if those databases include sensitive personal information or copyrighted works. However, one advantage of using an external memory is that the memory can be easily cleared of all such information, as we do at the end of each document that we train on. The same is not true of differentiable model parameters, which is what most existing architectures use to store facts and information that they are trained on. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            217
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REPRODUCIBILITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            237,
+            331,
+            252
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Details of our architecture and training hyperparameters are given in Section 4.2. The datasets for C4 and PG-19 are publicly available. Our additional datasets, Github, Isabelle, and ArXiv Math are derived from publicly available data buckets, which we link in the main part of the paper. Subsection 4.1 include details on how we constructed the datasets from those datasets. We plan to release our code as open source. ",
+        "bbox": [
+            174,
+            268,
+            825,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            285,
+            375
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joshua Ainslie, Santiago Ontañón, Chris Alberti, Vaclav Cvicek, Zachary Fisher, Philip Pham, Anirudh Ravula, Sumit Sanghai, Qifan Wang, and Li Yang. ETC: encoding long and structured inputs in transformers. In EMNLP, 2020. ",
+        "bbox": [
+            174,
+            382,
+            826,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie J. Cai, Michael Terry, Quoc V. Le, and Charles Sutton. Program synthesis with large language models. CoRR, abs/2108.07732, 2021. URL https://arxiv.org/abs/ 2108.07732. ",
+        "bbox": [
+            174,
+            433,
+            826,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Iz Beltagy, Matthew E. Peters, and Arman Cohan. Longformer: The long-document transformer. CoRR, abs/2004.05150, 2020. URL https://arxiv.org/abs/2004.05150. ",
+        "bbox": [
+            176,
+            497,
+            825,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, George Necula, Adam Paszke, Jake VanderPlas, Skye Wanderman-Milne, and Qiao Zhang. JAX: composable transformations of Python+NumPy programs, 2018. URL http://github.com/google/jax. ",
+        "bbox": [
+            173,
+            535,
+            826,
+            590
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom B. Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel M. Ziegler, Jeffrey Wu, Clemens Winter, Christopher Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. Language models are few-shot learners. In NeurIPS, 2020. ",
+        "bbox": [
+            174,
+            599,
+            826,
+            683
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harrison Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian, Clemens Winter, Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert-Voss, William Hebgen Guss, Alex Nichol, Alex Paino, Nikolas Tezak, Jie Tang, Igor Babuschkin, Suchir Balaji, Shantanu Jain, William Saunders, Christopher Hesse, Andrew N. Carr, Jan Leike, Joshua Achiam, Vedant Misra, Evan Morikawa, Alec Radford, Matthew Knight, Miles Brundage, Mira Murati, Katie Mayer, Peter Welinder, Bob McGrew, Dario Amodei, Sam McCandlish, Ilya Sutskever, and Wojciech Zaremba. Evaluating large language models trained on code. CoRR, abs/2107.03374, 2021. URL https://arxiv. org/abs/2107.03374. ",
+        "bbox": [
+            176,
+            691,
+            826,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Krzysztof Marcin Choromanski, Valerii Likhosherstov, David Dohan, Xingyou Song, Andreea Gane, Tamás Sarlós, Peter Hawkins, Jared Quincy Davis, Afroz Mohiuddin, Lukasz Kaiser, David Benjamin Belanger, Lucy J. Colwell, and Adrian Weller. Rethinking attention with performers. In ICLR, 2021. ",
+        "bbox": [
+            176,
+            867,
+            826,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems. CoRR, abs/2110.14168, 2021. URL https://arxiv.org/abs/2110.14168. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zihang Dai, Zhilin Yang, Yiming Yang, Jaime G. Carbonell, Quoc Viet Le, and Ruslan Salakhutdinov. Transformer-XL: Attentive language models beyond a fixed-length context. In ACL, 2019. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. In ACL, 2019. ",
+        "bbox": [
+            171,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Angela Fan, Thibaut Lavril, Edouard Grave, Armand Joulin, and Sainbayar Sukhbaatar. Addressing some limitations of transformers with feedback memory. arXiv preprint arXiv:2002.09402, 2020. ",
+        "bbox": [
+            171,
+            231,
+            825,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Angela Fan, Claire Gardent, Chloé Braud, and Antoine Bordes. Augmenting transformers with KNN-based composite memory for dialog. Transactions of the Association for Computational Linguistics, 9:82–99, 2021. ",
+        "bbox": [
+            173,
+            268,
+            825,
+            313
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Edouard Grave, Armand Joulin, and Nicolas Usunier. Improving neural language models with a continuous cache. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            320,
+            823,
+            351
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruiqi Guo, Philip Sun, Erik Lindgren, Quan Geng, David Simcha, Felix Chern, and Sanjiv Kumar. Accelerating large-scale inference with anisotropic vector quantization. In ICML, 2020. ",
+        "bbox": [
+            173,
+            358,
+            823,
+            388
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ankit Gupta, Guy Dar, Shaya Goodman, David Ciprut, and Jonathan Berant. Memory-efficient transformers via top- $\\mathbf { \\nabla } \\cdot \\mathbf { k }$ attention. CoRR, abs/2106.06899, 2021. URL https://arxiv.org/ abs/2106.06899. ",
+        "bbox": [
+            174,
+            397,
+            823,
+            439
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. Retrieval augmented language model pre-training. In ICML, 2020. ",
+        "bbox": [
+            174,
+            449,
+            823,
+            478
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christopher Hahn, Frederik Schmitt, Jens U. Kreber, Markus Norman Rabe, and Bernd Finkbeiner. Teaching temporal logics to neural networks. In ICLR, 2021. ",
+        "bbox": [
+            174,
+            486,
+            823,
+            516
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Heek, Anselm Levskaya, Avital Oliver, Marvin Ritter, Bertrand Rondepierre, Andreas Steiner, and Marc van Zee. Flax: A neural network library and ecosystem for JAX, 2020. URL http://github.com/google/flax. ",
+        "bbox": [
+            176,
+            525,
+            823,
+            568
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Henry, Prudhvi Raj Dachapally, Shubham Shantaram Pawar, and Yuxuan Chen. Query-key normalization for transformers. In EMNLP, 2020. ",
+        "bbox": [
+            171,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeff Johnson, Matthijs Douze, and Hervé Jégou. Billion-scale similarity search with GPUs. IEEE Transactions on Big Data, 2021. ",
+        "bbox": [
+            173,
+            614,
+            825,
+            645
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Urvashi Khandelwal, Omer Levy, Dan Jurafsky, Luke Zettlemoyer, and Mike Lewis. Generalization through memorization: Nearest neighbor language models. In ICLR, 2020. ",
+        "bbox": [
+            173,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nikita Kitaev, Łukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. In ICLR, 2020. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            720
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Taku Kudo and John Richardson. Sentencepiece: A simple and language independent subword tokenizer and detokenizer for neural text processing. In EMNLP, 2018. ",
+        "bbox": [
+            173,
+            729,
+            823,
+            758
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Lample, Alexandre Sablayrolles, Marc’Aurelio Ranzato, Ludovic Denoyer, and Hervé Jégou. Large memory layers with product keys. In NeurIPS, 2019. ",
+        "bbox": [
+            173,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mike Lewis, Marjan Ghazvininejad, Gargi Ghosh, Armen Aghajanyan, Sida Wang, and Luke Zettlemoyer. Pre-training via paraphrasing. In NeurIPS, 2020a. ",
+        "bbox": [
+            173,
+            804,
+            823,
+            834
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, et al. Retrieval-augmented generation for knowledge-intensive NLP tasks. In NeurIPS, 2020b. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenda Li, Lei Yu, Yuhuai Wu, and Lawrence C. Paulson. Isarstep: a benchmark for high-level mathematical reasoning. In ICLR, 2021. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, David Choi, Junyoung Chung, Nate Kushman, Julian Schrittwieser, Rémi Leblond, Tom Eccles, James Keeling, Felix Gimeno, Agustin Dal Lago, Thomas Hubert, Peter Choy, Cyprien de Masson d’Autume, Igor Babuschkin, Xinyun Chen, Po-Sen Huang, Johannes Welbl, Sven Gowal, Alexey Cherepanov, James Molloy, Daniel J. Mankowitz, Esme Sutherland Robson, Pushmeet Kohli, Nando de Freitas, Koray Kavukcuoglu, and Oriol Vinyals. Competition-level code generation with alphacode. DeepMind, 2022. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stanislas Polu and Ilya Sutskever. Generative language modeling for automated theorem proving. CoRR, abs/2009.03393, 2020. URL https://arxiv.org/abs/2009.03393. ",
+        "bbox": [
+            178,
+            195,
+            823,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Markus Norman Rabe, Dennis Lee, Kshitij Bansal, and Christian Szegedy. Mathematical reasoning via self-supervised skip-tree training. In ICLR, 2021. ",
+        "bbox": [
+            174,
+            233,
+            821,
+            262
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jack W Rae, Anna Potapenko, Siddhant M Jayakumar, Chloe Hillier, and Timothy P Lillicrap. Compressive transformers for long-range sequence modelling. In ICLR, 2020. ",
+        "bbox": [
+            174,
+            270,
+            820,
+            299
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 2020. ",
+        "bbox": [
+            176,
+            306,
+            823,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongyu Ren, Hanjun Dai, Zihang Dai, Mengjiao Yang, Jure Leskovec, Dale Schuurmans, and Bo Dai. Combiner: Full attention transformer with sparse computation cost. CoRR, abs/2107.05768, 2021. URL https://arxiv.org/abs/2107.05768. ",
+        "bbox": [
+            174,
+            357,
+            826,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aurko Roy, Mohammad Saffar, Ashish Vaswani, and David Grangier. Efficient content-based sparse attention with routing transformers. Transactions of the Association for Computational Linguistics, 9:53–68, 2021. ",
+        "bbox": [
+            174,
+            409,
+            826,
+            450
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Noam Shazeer and Mitchell Stern. Adafactor: Adaptive learning rates with sublinear memory cost. In ICML, 2018. ",
+        "bbox": [
+            173,
+            459,
+            823,
+            488
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Edouard Grave, Guillaume Lample, Herve Jegou, and Armand Joulin. Augmenting self-attention with persistent memory. arXiv preprint arXiv:1907.01470, 2019. ",
+        "bbox": [
+            173,
+            496,
+            823,
+            526
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Da Ju, Spencer Poff, Stephen Roller, Arthur Szlam, Jason Weston, and Angela Fan. Not all memories are created equal: Learning to forget by expiring. In ICML, 2021. ",
+        "bbox": [
+            176,
+            534,
+            823,
+            563
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Simeng Sun, Kalpesh Krishna, Andrew Mattarella-Micke, and Mohit Iyyer. Do long-range language models actually use long-range context? In EMNLP, 2021. ",
+        "bbox": [
+            173,
+            570,
+            821,
+            599
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. arXiv preprint arXiv:2009.06732, 2020. ",
+        "bbox": [
+            176,
+            607,
+            821,
+            637
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena: A benchmark for efficient transformers. In ICLR, 2021. ",
+        "bbox": [
+            174,
+            645,
+            826,
+            688
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017. ",
+        "bbox": [
+            171,
+            695,
+            823,
+            724
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Qingxiang Wang, Chad Brown, Cezary Kaliszyk, and Josef Urban. Exploration of neural machine translation in autoformalization of mathematics in mizar. In International Conference on Certified Programs and Proofs, 2020a. ",
+        "bbox": [
+            173,
+            733,
+            825,
+            775
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sinong Wang, Belinda Z Li, Madian Khabsa, Han Fang, and Hao Ma. Linformer: Self-attention with linear complexity. arXiv preprint arXiv:2006.04768, 2020b. ",
+        "bbox": [
+            171,
+            784,
+            823,
+            813
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xun Wang, Haozhi Zhang, Weilin Huang, and Matthew R. Scott. Cross-batch memory for embedding learning. In CVPR, 2020c. ",
+        "bbox": [
+            173,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J. Williams and Jing Peng. An efficient gradient-based algorithm for on-line training of recurrent network trajectories. Neural Computation, 1990. ",
+        "bbox": [
+            173,
+            858,
+            821,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dani Yogatama, Cyprien de Masson d’Autume, and Lingpeng Kong. Adaptive semiparametric language models. ACL, 9:362–373, 2021. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Manzil Zaheer, Guru Guruganesh, Kumar Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontañón, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, and Amr Ahmed. Big bird: Transformers for longer sequences. In NeurIPS, 2020. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yury Zemlyanskiy, Joshua Ainslie, Michiel de Jong, Philip Pham, Ilya Eckstein, and Fei Sha. Readtwice: Reading very large documents with memories. In ACL: Human Language Technologies, 2021. ",
+        "bbox": [
+            174,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhenhai Zhu and Radu Soricut. H-transformer-1d: Fast one-dimensional hierarchical attention for sequences. In ACL, 2021. ",
+        "bbox": [
+            171,
+            207,
+            823,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A LENGTH OF INPUTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            375,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/590dba826b536883dbd7b839ee67cfd0767b9162d302b75f3df6ce355c757fe0.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            137,
+            820,
+            190
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 9: Histogram of the number of tokens in arXiv math papers dataset. We tuncated the histogram at 500k tokens. The maximum paper had almost 1.6M tokens. ",
+        "bbox": [
+            171,
+            203,
+            821,
+            232
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/392ac5da3e6f25f1ea04b96cb84fa3eff4102cd04a0f0ce5ff97fef8be49ba65.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            246,
+            821,
+            301
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 10: Histogram of the number of tokens in Github repositories dataset. We cut off the long tail of this plot. The repository with the maximum length has just over 9M tokens. ",
+        "bbox": [
+            171,
+            314,
+            823,
+            343
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/869058a85d9ebbb8cb3aece05d5f6c75030dc1420ab9ed7ce7b5e7a8cff0cae2.jpg",
+        "image_caption": [
+            "Figure 11: Histogram of the number of tokens in Isabelle proof scripts dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            358,
+            820,
+            412
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/bdeca69f56f05a45e94288812872dd89cc33979dff117d6c86f428d2a5fc1362.jpg",
+        "image_caption": [
+            "Figure 12: Histogram of the number of tokens in PG19 books dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            457,
+            820,
+            511
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/049c1502062b0ef6c727e79a603400063a529317f7c6978f8199ef3811fadea6.jpg",
+        "image_caption": [
+            "Figure 13: Histogram of the number of tokens in C4 documents filtered by documents that have less than 4096 tokens. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            554,
+            820,
+            607
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            356,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In the following section, we performed ablation studies to investigate the effects of various hyperparameters. Unless otherwise specified, we carried out these experiments with a memorizing transformer with context size 512, XL cache 512 with a memory size of 8192. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            171
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Multiple $k \\mathbf { N N }$ layers. We experimented with using two $k \\mathbf { N N }$ layers, rather than just one. However, we did not see further benefits brought by more than multiple retrieval layers. ",
+        "bbox": [
+            174,
+            186,
+            823,
+            215
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "$k \\mathbf { N N }$ layer index We experimented with adding the external memory to layer 3, 6, 9 and 12 in a 12-layer transformer, with results shown in Table 14. We found that adding memory to the middle of the layer stack will obtain the best result, whereas adding memory to layers either too close to the input or to the output obtained less gains. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            286
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/70af44f82e22b7385bd6dbe298c52907b4c7a64f7f87918a633ee0be210798d2.jpg",
+        "table_caption": [
+            "Table 14: Different layer index. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer index</td><td>Perplexity</td></tr><tr><td>3</td><td>2.40</td></tr><tr><td>6</td><td>2.36</td></tr><tr><td>9</td><td>2.37</td></tr><tr><td>12</td><td>2.43</td></tr></table>",
+        "bbox": [
+            398,
+            335,
+            598,
+            426
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Number of neighbors We studied the effects of the number of neighbors we retrieve from memory, with results shown in Table 15. We found that even with 32 number of neighbors, we can already obtain a comparable results with 128 or 256 neighbors. ",
+        "bbox": [
+            174,
+            450,
+            826,
+            493
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/0d2009b64b5845b15ab5ce864c14f087c2773bbcadd1c93b710156037edf6b71.jpg",
+        "table_caption": [
+            "Table 15: Number of neighbors. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Number of neighbors</td><td>Perplexity</td></tr><tr><td>32</td><td>2.38</td></tr><tr><td>128</td><td>2.37</td></tr><tr><td>256</td><td>2.37</td></tr></table>",
+        "bbox": [
+            367,
+            541,
+            630,
+            618
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Random seeds We measured the statistical significant of the results reported. We did 3 runs with 3 random seeds for Transformer XL of size 512, and also a memorizing transformer with memory size 8192. We measured the standard deviation of perplexities after 500K steps of training, shown in Table 16. We saw the standard deviation between different runs of the same experiment appears to be much smaller than the gap between different models. ",
+        "bbox": [
+            173,
+            642,
+            825,
+            712
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/ac5365688e10dead3907cd7d2436c635a339a5c8ce323a9ee3f11d67937fc5ba.jpg",
+        "table_caption": [
+            "Table 16: Random seeds. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Perplexity</td></tr><tr><td>Transformer XL</td><td>2.67± 0.01</td></tr><tr><td>Memorizing Transformer</td><td>2.37 ± 0.005</td></tr></table>",
+        "bbox": [
+            367,
+            761,
+            630,
+            814
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B WHAT DOES THE MODEL RETRIEVE FROM MEMORY? ",
+        "bbox": [
+            174,
+            102,
+            645,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Retrieving citation names On arXiv math, several examples are shown in Table 17, which includes both the retrieved token and its surrounding context. We observe that many of the gains in crossentropy loss took place when trying to predict the name of bibitems, citations, or references, by looking up the references and citations used previously in the paper. Such lookups usually span over the entire paper, which is much longer than 8192 tokens, providing a plausible explanation for the gain beyond memory size of 8192. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            217
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/f0823719b76942ff54990140f592457ad251405b00ddeb20b85a6f2c4f05b204.jpg",
+        "table_caption": [
+            "Table 17: The table shows several examples of which tokens were retrieved during language modelling of arXiv math dataset. The model is retrieving names of the references from previous passages. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Query index1</td><td>Input</td><td></td><td>tTargetSurrounding context</td><td></td><td>Retrieved index Retrieved surrounding context</td></tr><tr><td>20389</td><td>Mon</td><td>thus</td><td>bibitem{ComtetMonthusYor</td><td>2208</td><td>Brownian motion \\cite{ComtetMonthus Yor</td></tr><tr><td>16623</td><td>cha</td><td>kra</td><td>\\cite{ chakrabarti)</td><td>4677</td><td>~1.2 of\\cite{chakrabarti</td></tr><tr><td>14747</td><td>as</td><td>d</td><td>\\eqref( asdfg ) }which</td><td>3365</td><td>begin{equation}\\n \\labelt asdfg</td></tr></table>",
+        "bbox": [
+            173,
+            256,
+            823,
+            316
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Retrieving function names from the codebase As with the arXiv papers, we also studied which tokens the model retrieved from memory. As might be expected, the model is often looking up the names of functions, and variables, as shown in Table 18. ",
+        "bbox": [
+            174,
+            325,
+            825,
+            367
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/9f34896ea4cb386413a8a8f9da6a94e95e5f6a1b3f29c08e898d3e2c626cfe15.jpg",
+        "table_caption": [
+            "Table 18: Examples of memory retrieval in the Github dataset. The model looks up how functions are used elsewhere in the repository. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Query index</td><td>Input</td><td></td><td>TargetSurrounding context</td><td></td><td>Retrieved indexRetrieved surrounding context</td></tr><tr><td>23837</td><td>Fo</td><td>nte</td><td>menu_play-&gt; setarFonte</td><td>14607</td><td>menu_load-&gt; setarFonte</td></tr><tr><td>23825</td><td>，</td><td>35</td><td>hscreen/2-50,50,200,35 )；</td><td>14599</td><td>20, y+40,200,35)</td></tr><tr><td>14546</td><td>-&gt;</td><td>adi</td><td>panel-&gt; adicionaComponente</td><td>5205</td><td>panel-&gt; adicionaComponente</td></tr></table>",
+        "bbox": [
+            173,
+            421,
+            823,
+            491
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.1 MORE RETRIEVING EXAMPLES IN FORMAL THEOREM PROVING CORPU",
+        "text_level": 1,
+        "bbox": [
+            181,
+            104,
+            705,
+            117
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Example 1 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            130,
+            250,
+            145
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "• Input token index: 64604   \n• Input token: “_”   \n• Target token: “pair”   \n• Surrounding context: )) by (simp add: Fourier_sum_limit_pair [OF f, symmetric] Fourier’ • Name needs to be predicted: Fourier_sum_limit_pair   \n• Retrieved token: “Four”   \n• Retrieved token index: 64412   \n• Retrieved context: $2 ^ { \\ast } { \\mathfrak { n } }$ . Fourier_coefficient f k \\* trigonometric_set k t)   \n• Definition of the name: lemma Fourier sum limit pair: assumes\"f absolutely_integrable_on {-pi..pi}\" shows\"(入n. Ck<2 \\*n. Fourier_coefficient f k \\* trigonometric _set k t) 1 $\\longleftrightarrow$ (入n. k<n.Fourier_coefficient f k \\*trigonometric_setk t) 1\" (is \"?lhs $=$ ?rhs\") ",
+        "bbox": [
+            215,
+            156,
+            820,
+            387
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Example 2 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            435,
+            251,
+            449
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "• Input token index: 46175   \n• Input token: “tri”’   \n• Target token: “gon”   \n• Surrounding context: <le>n. a k \\* trigonometric_set k x) Name needs to be predicted: orthonormal_system_trigonometric_set Retrieved token: “gon”   \n• Retrieved token index: 35457   \n• Retrieved context: lemma orthonormal_system_trigonometric_set: $\\backslash \\mathrm { n }$ \"orthonormal_system   \n• Definition of the name: ",
+        "bbox": [
+            215,
+            460,
+            815,
+            627
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/83343cb6eed79c43cb0dd8e243d363d5ae700fb0872618464e56ae9135f177c1.jpg",
+        "image_caption": [
+            "Figure 19: Definition of Fourier_sum_limit_pair. ",
+            "Figure 20: Definition of orthonormal_system_trigonometric_set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            642,
+            718,
+            671
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Example 3 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            251,
+            118
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "• Input token index: 49760   \n• Input token: “sum”’   \n• Target token: “m”   \n• Surrounding context: nusing Fourier_series_square_summable [OF assms, of’   \n• Name needs to be predicted: Fourier_series_square_summable   \n• Retrieved token: “sum”   \n• Retrieved token index: 35457   \n• Retrieved context: lemma Fourier_series_square_summable\\n assumes:   \n• Definition of the name: ",
+        "bbox": [
+            215,
+            130,
+            745,
+            295
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Lemma Fourier series square summable: assumes os: \"orthonormal_system $\\textsf { S w } ^ { * }$ and w: \"∧i. (w i) square_integrable S\" and f: \"f square integrable S\" shows \"summable (confine (λi. (orthonormal_coeff S w f i) $\\sim 2$ ） I)\" ",
+        "bbox": [
+            272,
+            310,
+            723,
+            348
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Figure 21: Definition of Fourier_series_square_summable. ",
+        "bbox": [
+            267,
+            363,
+            728,
+            377
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Example 4 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            396,
+            251,
+            410
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "• Input token index: 49697   \n• Input token: “_”’   \n• Target token: “system”   \n• Surrounding context: lemma Riemann_lebesgue_square_integrable: nassumes \"orthonormal_system S w   \n• Name needs to be predicted: orthonormal_system   \n• Retrieved token: “system”   \n• Retrieved token index: 28052   \n• Retrieved context: definition orthonormal_system :: \"\\’a::euclidean’   \n• Definition of the name: ",
+        "bbox": [
+            215,
+            422,
+            681,
+            602
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "definition orthonormal_system :: \"'a::euclidean_space ${ \\mathsf { s e t } } \\Rightarrow ( ^ { \\mathrm { ~ \\iota ~ } } \\mathsf { b } \\Rightarrow ^ { \\mathrm { ~ \\iota ~ } } \\mathsf { a } \\Rightarrow \\mathsf { r e a l } ) \\Rightarrow \\mathsf { b o o l } ^ { \\mathrm { ~ \\iota ~ } }$ where\"orthonormal_system ${ \\sf S } \\ w \\equiv \\forall \\mathfrak { m } \\ \\mathfrak { n }$ .l2product S (wm)(wn) $=$ (if m = n then 1 else 0)\" ",
+        "bbox": [
+            210,
+            616,
+            790,
+            637
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Example 5 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            251,
+            118
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "• Input token index: 34817   \n• Input token: “.”’   \n• Target token: “b”   \n• Surrounding context: shows \"integrable (lebesgue_on {a..b})   \n• Retrieved token 1: “.”   \n• Retrieved token index 1: 2416   \n• Retrieved context 1: lebesgue_on {a..b}) f i   \n• Retrieved token 2: “-”   \n• Retrieved token index 2: 2445   \n• Retrieved context 2: (lebesgue_on {a-c..b-c}) (   \n• Retrieved token 3: “-”   \n• Retreived token index 3: 6479   \n• Retrieved context 3: (lebesgue_on {-pi..pi}) ( ",
+        "bbox": [
+            215,
+            130,
+            635,
+            372
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "Example 6 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            386,
+            251,
+            401
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "• Input token index: 49759   \n• Input token: “_”’   \n• Target token: “sum”   \n• Surrounding context: $0 \" \\backslash \\mathtt { n }$ using Fourier_series_square_summable [OF assms   \n• Retrieved token 1: “set”   \n• Retrieved token index 1: 35044   \n• Retrieved context 1: definition trigonometric_set :: \"nat \\<Rightarrow>   \n• Retrieved token 2: “ier”   \n• Retrieved token index 2: 47272   \n• Retrieved context 2: definition Fourier_coefficient\\nwhere   \n• Retrieved token 3: “ine”   \n• Retrieved token index 3: 18160   \n• Retrieved context 3: lemma Schwartz_inequality_strong:\\nassumes “f’   \n• Retrieved token 4: “system”   \n• Retrieved token index 4: 28052   \n• Retrieved context 4: definition orthonormal_system :: “\\’a::euclidean’   \n• Retrieved token 5: “<”   \n• Retrieved token index 5: 47241   \n• Retrieved context 5: subsection\\<open>Convergence wrt the L’   \n• Retrieved token 6: “n”   \n• Retrieved token index 6: 40835   \n• Retrieved context 6: \\n subsection\\<open>A bit of extra’ ",
+        "bbox": [
+            215,
+            414,
+            746,
+            827
+        ],
+        "page_idx": 18
+    }
+]

parse/dev/Yacmpz84TH/Yacmpz84TH.md

@@ -0,0 +1,281 @@
+# Toolformer: Language Models Can Teach Themselves to Use Tools
+
+Timo Schick Jane Dwivedi-Yu Roberto Dessì† Roberta Raileanu Maria Lomeli Eric Hambro Luke Zettlemoyer Nicola Cancedda Thomas Scialom
+
+FAIR, Meta †Universitat Pompeu Fabra
+
+# Abstract
+
+Language models (LMs) exhibit remarkable abilities to solve new tasks from just a few examples or textual instructions, especially at scale. They also, paradoxically, struggle with basic functionality, such as arithmetic or factual lookup, where much simpler and smaller specialized models excel. In this paper, we show that LMs can teach themselves to use external tools via simple APIs and achieve the best of both worlds. We introduce Toolformer, a model trained to decide which APIs to call, when to call them, what arguments to pass, and how to best incorporate the results into future token prediction. This is done in a self-supervised way, requiring nothing more than a handful of demonstrations for each API. We incorporate a range of tools, including a calculator, a Q&A system, a search engine, a translation system, and a calendar. Toolformer achieves substantially improved zero-shot performance across a variety of downstream tasks, often competitive with much larger models, without sacrificing its core language modeling abilities.
+
+# 1 Introduction
+
+Large language models achieve impressive zero and few-shot results on a variety of natural language processing tasks (Brown et al., 2020; Chowdhery et al., 2022, i.a.). However, these models have several inherent limitations that can at best be partially addressed by further scaling. These limitations include an inability to access up-to-date information on recent events (Komeili et al., 2022) and the related tendency to hallucinate facts (Maynez et al., 2020; Ji et al., 2022), difficulties in understanding low-resource languages (Lin et al., 2021), a lack of mathematical skills to perform precise calculations (Patel et al., 2021) and an unawareness of the progression of time (Dhingra et al., 2022).
+
+A simple way to overcome the limitations of today’s language models is to give them the ability to use external tools such as search engines, calculators, or calendars. However, existing approaches either rely on large amounts of human annotations (Komeili et al., 2022; Thoppilan et al., 2022) or limit tool use to task-specific settings only (e.g., Gao et al., 2022; Parisi et al., 2022), hindering a more widespread adoption of tool use in LMs. Therefore, we propose Toolformer, a model that learns to use tools in a novel way, which fulfills the following desiderata:
+
+• Tool use should be learned in a self-supervised way without large amounts of human annotations. This is important not only because of the costs associated with such annotations, but also because what humans find useful may be different from what a model finds useful. • The LM should not lose any of its generality and should be able to decide for itself when and how to use which tool. In contrast to existing approaches, this enables a much more comprehensive use of tools that is not tied to specific tasks.
+
+Our approach for achieving these goals is based on the recent idea of using large LMs with in-context learning (Brown et al., 2020) to generate entire datasets from scratch (Schick and Schütze, 2021b;
+
+![](images/efd2dac35f6d1a63826328723565885e1aad2ceea0a3379b92e4c40bd9922f6b.jpg)  
+Figure 1: Exemplary predictions of Toolformer. The model autonomously decides to call different APIs (from top to bottom: a question answering system, a calculator, a machine translation system, and a Wikipedia search engine) to obtain information that is useful for completing a piece of text.
+
+![](images/5869d239001ffcca88eb10a98a653d9f154d0247150188f33783d20eda69ab5b.jpg)  
+Figure 2: Key steps in ourwe first sample a position pproach, illustrated for a question answe and corresponding API call candidates en an input text . We then execu $\mathbf { x }$ , $i$ $c _ { i } ^ { 1 } , c _ { i } ^ { 2 } , \ldots , c _ { i } ^ { k }$ these API calls and filter out all calls which do not reduce the loss $L _ { i }$ over the next tokens. All remaining API calls are interleaved with the original text, resulting in a new text $\mathbf { x } ^ { * }$ .
+
+Honovich et al., 2022; Wang et al., 2022): Given just a handful of human-written examples of how an API can be used, we let a LM annotate a huge language modeling dataset with potential API calls. We then use a self-supervised loss to determine which of these API calls actually help the model in predicting future tokens. Finally, we finetune the LM itself on the API calls that it considers useful. As illustrated in Figure 1, through this simple approach, LMs can learn to control a variety of tools, and to choose for themselves which tool to use when and how.
+
+As our approach is agnostic of the dataset being used, we can apply it to the exact same dataset that was used to pretrain a model in the first place. This ensures that the model does not lose any of its generality and language modeling abilities. We conduct experiments on a variety of different downstream tasks, demonstrating that after learning to use tools, Toolformer, which is based on a pretrained GPT-J model (Wang and Komatsuzaki, 2021) with 6.7B parameters, achieves much stronger zero-shot results, clearly outperforming a much larger GPT-3 model (Brown et al., 2020) and several other baselines on various tasks.
+
+# 2 Approach
+
+Our aim is to equip a language model $M$ with the ability to use different tools through API calls. We represent API calls as tuples $c = ( a _ { c } , i _ { c } )$ where $a _ { c }$ is the name of the API and $i _ { c }$ is the corresponding input. Given an API call $c$ with a corresponding result $r$ , we denote the linearized sequences of the API call not including and including its result, respectively, as:
+
+$$
+\begin{array} { r } { \mathsf { e } ( c ) = < \mathtt { A P I } > a _ { c } ( i _ { c } ) < / \mathtt { A P I } > \mathsf { e } ( c , r ) = < \mathtt { A P I } > a _ { c } ( i _ { c } ) \to r < / \mathtt { A P I } > } \end{array}
+$$
+
+where $ { \mathrm { ~  ~ \cdots ~ } } < \tt { A P I } >  { \mathrm { ^ { \circ } } }$ , $ { \mathrm { ~  ~ \cdots ~ } } < / \tt A P I >  { \mathrm { ^ { \circ } } }$ and $\ "  \ "$ are special tokens.1 Some examples of linearized API calls inserted into text sequences are shown in Figure 1.
+
+Your task is to add calls to a Question Answering API to a piece of text. The questions should help you get information required to complete the text. You can call the API by writing "[QA(question)]" where "question" is the question you want to ask. Here are some examples of API calls:
+
+Input: Joe Biden was born in Scranton, Pennsylvania.   
+Output: Joe Biden was born in [QA("Where was Joe Biden born?")] Scranton, [QA("In which state is Scranton?")] Pennsylvania.
+
+Input: Coca-Cola, or Coke, is a carbonated soft drink manufactured by the Coca-Cola Company. Output: Coca-Cola, or [QA("What other name is Coca-Cola known by?")] ${ \mathsf { C o k e } } ,$ , is a carbonated soft drink manufactured by [QA("Who manufactures Coca-Cola?")] the Coca-Cola Company.
+
+Input: x Output:
+
+Given a dataset $\mathcal { C } = \{ \mathbf { x } ^ { 1 } , \ldots , \mathbf { x } ^ { | \mathcal { C } | } \}$ of plain texts, we first convert this dataset into a dataset $\mathcal { C } ^ { * }$ augmented with API calls. This is done in three steps, illustrated in Figure 2: First, we exploit the in-context learning ability of $M$ to sample a large number of API calls. We then execute them and finally check whether the obtained responses are helpful for predicting future tokens; this is used as a filtering criterion. After filtering, we merge API calls for different tools, resulting in the augmented dataset $\mathcal { C } ^ { * }$ , and finetune $M$ itself on this dataset. Each step is described in more detail below.
+
+Sampling API Calls For each API, we write a prompt $P ( \mathbf { x } )$ that encourages the LM to annotate an example $\mathbf { x } = x _ { 1 } , \ldots , x _ { n }$ with API calls. An example of such a prompt for a question answering tool is shown in Figure 3. Let $p _ { M } ( z _ { n + 1 } \mid z _ { 1 } , . . . , z _ { n } )$ be the probability that $M$ assigns to token $z _ { n + 1 }$ as a continuation for the sequence $z _ { 1 } , \ldots , z _ { n }$ . We first sample up to $k$ candidate positions for doing API calls by computing, for each $i \in \{ 1 , \ldots , n \}$ , the probability $p _ { i } = p _ { M } ( < _ { \tt A P I > } \mid P ( \mathbf { x } ) , x _ { 1 : i - 1 } )$ that $M$ assigns to starting an API call at position $i$ . Given a sampling threshold $\tau _ { s }$ , we keep all positions $I \stackrel { - } { = } \{ i | p _ { i } > \tau _ { s } \stackrel { - } { \} }$ ; if there are more than $k$ such positions, we only keep the top $k$ . For each position $i \in I$ , we then obtain up to $m$ API calls $c _ { i } ^ { 1 } , \ldots , c _ { i } ^ { m }$ by sampling from $M$ given the sequence $[ P ( \mathbf { x } ) , x _ { 1 } , \ldots , x _ { i - 1 } , < \mathtt { A P I } > ]$ as a prefix and ${ < } / { \tt A P I > }$ as an end-of-sequence token.
+
+Executing API Calls As a next step, we execute all API calls generated by $M$ . How this is done depends entirely on the API itself – for example, it can involve calling another neural network, executing a Python script or using a retrieval system to perform search over a large corpus. The response for each API call $c _ { i }$ needs to be a single text sequence $r _ { i }$ .
+
+Filtering API Calls Let $i$ be the position of the API call $c _ { i }$ in the sequence $\mathbf { x } = x _ { 1 } , \ldots , x _ { n }$ , and let $r _ { i }$ be the response from the API. Further, given a sequence $( w _ { i } \mid i \in \mathbb { N } )$ of weights, let
+
+$$
+L _ { i } ( \mathbf { z } ) = - \sum _ { j = i } ^ { n } w _ { j - i } \cdot \log p _ { M } ( x _ { j } \mid \mathbf { z } , x _ { 1 : j - 1 } )
+$$
+
+be the weighted cross entropy loss for $M$ over the tokens $x _ { i } , \ldots , x _ { n }$ if the model is prefixed with some text sequence $\mathbf { z }$ . We compare two different instantiations of this loss:
+
+$$
+L _ { i } ^ { + } = L _ { i } ( \mathbf { e } ( c _ { i } , r _ { i } ) ) \qquad L _ { i } ^ { - } = \operatorname* { m i n } \left( L _ { i } ( \varepsilon ) , L _ { i } ( \mathbf { e } ( c _ { i } , \varepsilon ) ) \right)
+$$
+
+where $\varepsilon$ denotes an empty sequence. The former is the weighted loss over all tokens $x _ { i } , \ldots , x _ { n }$ if the API call and its result are given to $M$ as a prefix;2 the latter is the minimum of the losses obtained from (i) doing no API call at all and (ii) doing an API call, but not providing the response. Intuitively, an API call is helpful to $M$ if providing it with both the input and the output of this call makes it easier for the model to predict future tokens, compared to not receiving the API call at all, or receiving only its input. Given a filtering threshold $\tau _ { f }$ , we thus only keep API calls for which $L _ { i } ^ { - } - L _ { i } ^ { + } \ge \tau _ { f }$ holds, i.e., adding the API call and its result reduces the loss by at least $\tau _ { f }$ , compared to not doing any API call or obtaining no result from it.
+
+Table 1: Examples of inputs and outputs for all APIs used.   
+
+<table><tr><td>API Name</td><td>Example Input</td><td>Example Output</td></tr><tr><td>Question Answering</td><td>Where was the Knights of Columbus founded?</td><td>New Haven, Connecticut</td></tr><tr><td>Wikipedia Search</td><td>Fishing Reel Types</td><td>Spin fishing &gt; Spin fishing is distinguished between fly fishing and bait cast fishing by the type of rod and reel used. There are two types of reels used when spin fishing,</td></tr><tr><td>Calculator</td><td>27+4*2</td><td>the open faced reel and the closed faced reel. 35</td></tr><tr><td>Calendar</td><td>m</td><td>Today is Monday, January 30,2023.</td></tr><tr><td>Machine Translation</td><td>sureté nucléaire</td><td>nuclear safety</td></tr></table>
+
+Model Finetuning After sampling and filtering calls for all APIs, we finally merge the remaining API calls and interleave them with the original inputs. That is, for an input text $\mathbf { x } = x _ { 1 } , \ldots , x _ { n }$ with a corresponding API call and result $( c _ { i } , r _ { i } )$ at position $i$ , we construct the new sequence $\mathbf { x } ^ { * } = x _ { 1 : i - 1 } , \mathbf { e } ( c _ { i } , r _ { i } ) , x _ { i : n }$ ; we proceed analogously for texts with multiple API calls. Doing this for all $\mathbf { x } \in { \mathcal { C } }$ results in the new dataset $\mathcal { C } ^ { * }$ augmented with API calls. We use $\mathcal { C } ^ { * }$ to finetune $M$ , using a standard language modeling objective. Crucially, apart from inserted API calls, $\mathcal { C } ^ { * }$ contains the exact same texts as $\mathcal { C }$ , the original dataset. As a consequence, finetuning $M$ on $\mathcal { C } ^ { * }$ exposes it to the same content as finetuning on $\mathcal { C }$ . Moreover, as API calls are inserted in exactly those positions and with exactly those inputs that help $M$ predict future tokens, finetuning on $\mathcal { C } ^ { * }$ enables the language model to decide when and how to use which tool, based purely on its own feedback.
+
+Inference When generating text with $M$ after finetuning with our approach, we perform regular decoding until $M$ produces the $\ "  \ "$ token, indicating that it next expects the response for an API call. At this point, we interrupt the decoding process, call the appropriate API to get a response, and continue the decoding process after inserting both the response and the ${ < } / \tt { A P I > }$ token.
+
+# 3 Tools
+
+We explore various tools to address different shortcomings of LMs. The only constraints we impose are that (i) their inputs and outputs can be represented as texts, and (ii) we can obtain a few demonstrations of their intended use. Concretely, we explore a question answering system, a Wikipedia search engine, a calculator, a calendar, and a machine translation system. Examples for the APIs associated with each of these tools are shown in Table 1. We briefly discuss all tools below.
+
+Question Answering Our first tool is a question answering system based on another LM that can answer simple factoid questions. Specifically, we use Atlas (Izacard et al., 2022), a retrievalaugmented LM finetuned on Natural Questions (Kwiatkowski et al., 2019).
+
+Calculator As a second tool, we use a calculator that can perform simple numeric calculations; we only support the four basic arithmetic operations. Results are always rounded to two decimal places.
+
+Wikipedia Search Our third tool is a search engine that, given a search term, returns short text snippets from Wikipedia. Compared to our question answering tool, this search enables a model to get more comprehensive information on a subject, but requires it to extract the relevant parts by itself. As our search engine, we use a BM25 retriever (Robertson et al., 1995; Baeza-Yates et al., 1999) that indexes the Wikipedia dump from KILT (Petroni et al., 2021).
+
+Machine Translation System Our fourth tool is a machine translation system based on a LM that can translate a phrase from any language into English. More concretely, we use the 600M parameter NLLB (Costa-jussà et al., 2022) as our multilingual machine translation model that works for 200 languages (including low-resource ones). The source language is automatically detected using the fastText classifier (Joulin et al., 2016), while the target language is always set to English.
+
+Calendar Our final tool is a calendar API that, when queried, returns the current date without taking any input. This provides temporal context for predictions that require some awareness of time.
+
+Table 2: Number of examples with API calls in $\mathcal { C } ^ { * }$ for different values of our filtering threshold $\tau _ { f }$   
+
+<table><tr><td></td><td colspan="3">Number of Examples</td></tr><tr><td>API</td><td>Tf = 0.5</td><td>Tf = 1.0</td><td>Tf = 2.0</td></tr><tr><td>Question Answering</td><td>51,987</td><td>18,526</td><td>5,135</td></tr><tr><td>Wikipedia Search</td><td>207,241</td><td>60,974</td><td>13,944</td></tr><tr><td>Calculator</td><td>3,680</td><td>994</td><td>138</td></tr><tr><td>Calendar</td><td>61,811</td><td>20,587</td><td>3,007</td></tr><tr><td>Machine Translation</td><td>3,156</td><td>1,034</td><td>229</td></tr></table>
+
+# 4 Experiments
+
+We investigate whether our approach enables a LM to use tools without any further supervision and to decide for itself when and how to call which tool. To test this, we select a variety of downstream tasks where we assume at least one of the considered tools to be useful, and evaluate performance in zero-shot settings (Section 4.2). Beyond that, we also ensure that our approach does not hurt the model’s core LM abilities; we verify this by looking at perplexity on two language modeling datasets (Section 4.3). Finally, we investigate how tool use is affected by model size (Section 4.4).
+
+# 4.1 Experimental Setup
+
+We use a subset of CCNet (Wenzek et al., 2020) as our dataset $\mathcal { C }$ and GPT-J (Wang and Komatsuzaki, 2021) as our language model $M$ . To reduce the computational cost of annotating $\mathcal { C }$ with API calls, we define heuristics for some APIs to get a subset of $\mathcal { C }$ for which API calls are more likely to be helpful than for an average text. For example, we only consider texts for the calculator tool if they contain at least three numbers. Details of the heuristics used are given in Appendix A. For obtaining $\mathcal { C } ^ { * }$ from $\mathcal { C }$ , we perform all steps described in Section 2 and additionally filter out all examples for which all API calls were eliminated in the filtering step.3 For the weighting function, we use
+
+$$
+w _ { t } = \frac { \tilde { w } _ { t } } { \sum _ { s \in \mathbb { N } } \tilde { w } _ { s } } \mathrm { ~ w i t h ~ } \tilde { w } _ { t } = \operatorname* { m a x } ( 0 , 1 - 0 . 2 \cdot t )
+$$
+
+to make sure that API calls happen close to where the information provided by the API is actually helpful for the model. The thresholds $\tau _ { s }$ and $\tau _ { f }$ are chosen individually for each tool to ensure a sufficient number of examples; see Appendix A for details. Table 2 shows relevant statistics of our final dataset augmented with API calls. We finetune $M$ on $\mathcal { C } ^ { * }$ using a batch size of 128 and a learning rate of $1 \cdot 1 0 ^ { - 5 }$ with linear warmup for the first $10 \%$ of training. Finetuning details are given in Appendix B. In our experiments, we mainly compare GPT-J and the following models:
+
+• GPT- $\mathbf { J } + \mathbf { C } \mathbf { C }$ : GPT-J finetuned on $\mathcal { C }$ , our subset of CCNet without any API calls. • Toolformer: GPT-J finetuned on $\mathcal { C } ^ { * }$ , our subset of CCNet augmented with API calls. • Toolformer (disabled): The same model as Toolformer, but API calls are disabled during decoding. This is achieved by manually setting the probability of the ${ \tt { < A P I > } }$ token to 0.
+
+We additionally compare to OPT (66B) (Zhang et al., 2022) and the original davinci variant of GPT-3 (175B) (Brown et al., 2020), two models that are about 10 and 25 times larger than GPT-J.
+
+# 4.2 Downstream Tasks
+
+We evaluate on various downstream tasks considering a prompted zero-shot setup: Models are instructed to solve each task in natural language (see Appendix C), but we provide no examples. This is in contrast to prior work on tool use (e.g., Gao et al., 2022; Parisi et al., 2022), where models are provided with dataset-specific examples of how a tool can be used to solve a concrete task. We choose this more challenging setup as we are interested in seeing whether Toolformer works in precisely those cases where a user does not specify in advance which tools should be used in which way.
+
+Table 3: Results on subsets of LAMA and various benchmarks requiring mathematical reasoning. For LAMA, Toolformer uses the question answering tool for most examples, clearly outperforming all baselines of the same size and achieving results competitive with GPT-3. For the math benchmarks, Toolformer makes extensive use of the calculator tool, clearly outperforming OPT and GPT-3. Best results with a GPT-J based model are shown in bold, best results overall are underlined.   
+
+<table><tr><td></td><td colspan="3">LAMA</td><td colspan="3">Math Benchmarks</td></tr><tr><td>Model</td><td>SQuAD</td><td>Google-RE</td><td>T-REx</td><td>ASDiv</td><td>SVAMP</td><td>MAWPS</td></tr><tr><td>GPT-J</td><td>17.8</td><td>4.9</td><td>31.9</td><td>7.5</td><td>5.2</td><td>9.9</td></tr><tr><td>GPT-J + CC</td><td>19.2</td><td>5.6</td><td>33.2</td><td>9.6</td><td>5.0</td><td>9.3</td></tr><tr><td>Toolformer (disabled)</td><td>22.1</td><td>6.3</td><td>34.9</td><td>14.8</td><td>6.3</td><td>15.0</td></tr><tr><td>Toolformer</td><td>33.8</td><td>11.5</td><td>53.5</td><td>40.4</td><td>29.4</td><td>44.0</td></tr><tr><td>OPT (66B)</td><td>21.6</td><td>2.9</td><td>30.1</td><td>6.0</td><td>4.9</td><td>7.9</td></tr><tr><td>GPT-3 (175B)</td><td>26.8</td><td>7.0</td><td>39.8</td><td>14.0</td><td>10.0</td><td>19.8</td></tr></table>
+
+We use greedy decoding, but with one modification for Toolformer: We let the model start an API call whenever ${ \tt { < A P I > } }$ is one of the $k$ most likely tokens. For $k = 1$ , this corresponds to regular greedy decoding; we instead use $k = 1 0$ to increase the disposition of our model to make use of APIs. At the same time, we allow at most one API call per input to make sure the model does not get stuck in a loop where it constantly calls APIs. The effect of these modifications is explored in Appendix E.
+
+LAMA We evaluate our models on the SQuAD, Google-RE and T-REx subsets of the LAMA benchmark (Petroni et al., 2019). For each of these subsets, the task is to complete a short statement with a missing fact (e.g., a date or a place). As LAMA was originally designed to evaluate masked LMs (e.g., Devlin et al., 2019), we filter out examples where the mask token is not the final token, so that all examples can be processed in a left-to-right fashion. To account for different tokenizations and added complexity from not informing the model that a single word is required, for all models we use a slightly more lenient evaluation criterion than exact match and simply check whether the correct word is within the first five words predicted by the model. As LAMA is based on statements obtained directly from Wikipedia, we prevent Toolformer from using the Wikipedia Search API to avoid giving it an unfair advantage. As shown in Table 3 (left), all GPT-J models without tool use achieve similar performance. Crucially, Toolformer clearly outperforms these baseline models, improving upon the best baseline by 11.7, 5.2 and 18.6 points, respectively. It also clearly outperforms OPT (66B) and GPT-3 (175B), despite both models being much larger. This is achieved because the model independently decides to ask the question answering tool for the required information in almost all cases $( 9 8 . 1 \% )$ ; for only very few examples, it uses a different tool $( 0 . 7 \% )$ or no tool at all $( 1 . 2 \% )$ .
+
+Math Benchmarks We test mathematical abilities on ASDiv (Miao et al., 2020), SVAMP (Patel et al., 2021) and the MAWPS benchmark (Koncel-Kedziorski et al., 2016). We again account for the fact that we test all models in a zero-shot setup by using a more lenient evaluation criterion: As the required output is always a number, we simply check for the first number predicted by the model.4 Results are shown in Table 3 (right). While GPT-J and GPT- $\mathbf { J } + \mathbf { C } \mathbf { C }$ perform about the same, Toolformer achieves stronger results even without API calls. We surmise that this is because the model is finetuned on many examples of API calls and their results, improving its own mathematical capabilities. Nonetheless, allowing the model to make API calls more than doubles performance for all tasks, and also clearly outperforms the much larger OPT and GPT-3. This is because across all benchmarks, for $9 7 . 9 \%$ of all examples the model decides to ask the calculator tool for help.
+
+Question Answering We look at Web Questions (Berant et al., 2013), Natural Questions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017). For evaluation, we check whether the first 20 words predicted by a model contain the correct answer instead of requiring an exact match. For Toolformer, we disable the question answering tool as this would make solving the tasks trivial. Results are shown in Table 4 (left). Once again, Toolformer clearly outperforms all other models based on GPT-J, relying on the Wikipedia search API $( 9 9 . 3 \% )$ to find relevant information. However,
+
+Table 4: Results for various question answering datasets and temporal datasets. Using the Wikipedia search tool for most examples, Toolformer clearly outperforms baselines of the same size, but falls short of GPT-3 (175B) for question answering tasks. For temporal datasets, Toolformer outperforms all baselines, but does not make use of the calendar tool for TEMPLAMA.   
+
+<table><tr><td></td><td colspan="3">LAMA</td><td colspan="2">Temporal Datasets</td></tr><tr><td>Model</td><td>WebQS</td><td>NQ</td><td>TriviaQA</td><td>TEMPLAMA</td><td>DATESET</td></tr><tr><td>GPT-J</td><td>18.5</td><td>12.8</td><td>43.9</td><td>13.7</td><td>3.9</td></tr><tr><td>GPT-J + CC</td><td>18.4</td><td>12.2</td><td>45.6</td><td>12.9</td><td>2.9</td></tr><tr><td>Toolformer (disabled)</td><td>18.9</td><td>12.6</td><td>46.7</td><td>12.7</td><td>5.9</td></tr><tr><td>Toolformer</td><td>26.3</td><td>17.7</td><td>48.8</td><td>16.3</td><td>27.3</td></tr><tr><td>OPT (66B)</td><td>18.6</td><td>11.4</td><td>45.7</td><td>14.5</td><td>1.3</td></tr><tr><td>GPT-3 (175B)</td><td>29.0</td><td>22.6</td><td>65.9</td><td>15.5</td><td>0.8</td></tr></table>
+
+Table 5: Results on MLQA for Spanish (Es), German (De), Hindi $\mathrm { ( H i ) }$ , Vietnamese (Vi), Chinese (Zh) and Arabic (Ar). While using the MT tool to translate questions is helpful across all languages, further pretraining on CCNet deteriorates performance; thus, Toolformer does not consistently outperform GPT-J. The final rows correspond to models that are given contexts and questions in English.   
+
+<table><tr><td>Model</td><td>Es</td><td>De</td><td>Hi</td><td>Vi</td><td>Zh</td><td>Ar</td></tr><tr><td>GPT-J</td><td>15.2</td><td>16.5</td><td>1.3</td><td>8.2</td><td>18.2</td><td>8.2</td></tr><tr><td>GPT-J + CC</td><td>15.7</td><td>14.9</td><td>0.5</td><td>8.3</td><td>13.7</td><td>4.6</td></tr><tr><td>Toolformer (disabled)</td><td>19.8</td><td>11.9</td><td>1.2</td><td>10.1</td><td>15.0</td><td>3.1</td></tr><tr><td>Toolformer</td><td>20.6</td><td>13.5</td><td>1.4</td><td>10.6</td><td>16.8</td><td>3.7</td></tr><tr><td>OPT (66B)</td><td>0.3</td><td>0.1</td><td>1.1</td><td>0.2</td><td>0.7</td><td>0.1</td></tr><tr><td>GPT-3 (175B)</td><td>3.4</td><td>1.1</td><td>0.1</td><td>1.7</td><td>17.7</td><td>0.1</td></tr><tr><td>GPT-J (All En)</td><td>24.3</td><td>27.0</td><td>23.9</td><td>23.3</td><td>23.1</td><td>23.6</td></tr><tr><td>GPT-3 (All En)</td><td>24.7</td><td>27.2</td><td>26.1</td><td>24.9</td><td>23.6</td><td>24.0</td></tr></table>
+
+Toolformer still lags behind the much larger GPT-3 (175B) model. This is likely due to both the simplicity of our search engine (in many cases, it returns results that are clearly not a good match for a given query) and the inability of Toolformer to interact with it, e.g., by reformulating its query if results are not helpful or by browsing through multiple of the top results.
+
+Multilingual QA We evaluate all models on MLQA (Lewis et al., 2019), a multilingual QA benchmark. Context for each question is provided in English, while the question can be in Arabic, German, Spanish, Hindi, Vietnamese, or Simplified Chinese. Our evaluation metric is the percentage of times the model’s generation, capped at 10 words, contains the correct answer. Results are shown in Table 5. API calls improve Toolformer’s performance for all languages, suggesting that it has learned to make use of the machine translation tool. Depending on the language, this tool is used for $6 3 . 8 \%$ to $9 4 . 9 \%$ of all examples; the only exception is Hindi, for which it is used in only $7 . 3 \%$ of cases. However, Toolformer does not consistently outperform GPT-J as finetuning on CCNet deteriorates performance for some languages. OPT and GPT-3 perform surprisingly weak across all languages, mostly because they fail to provide an answer in English despite being instructed to do so. A potential reason for GPT-J not suffering from this problem is that it was trained on more multilingual data than both OPT and GPT-3, including EuroParl (Koehn, 2005). As an upper bound, we also evaluate GPT-J and GPT-3 on a variant of MLQA where both the context and the question are provided in English. In this setup, GPT-3 performs better than all other models, supporting our hypothesis that its subpar performance on MLQA is due to the task’s multilingual aspect.
+
+Temporal Datasets We evaluate all models on TEMPLAMA (Dhingra et al., 2022) and a new dataset that we call DATESET. TEMPLAMA contains cloze queries about facts that change with time. DATESET, described in Appendix D, is generated through a series of templates, but populated using a combination of random dates/durations (e.g., “What day of the week was it 30 days ago?”). For both tasks, we use the same evaluation as for the original LAMA dataset. Results shown in Table 4 (right) illustrate that Toolformer outperforms all baselines for both TEMPLAMA and DATESET. However, closer inspection shows that improvements on TEMPLAMA can not be attributed to the calendar tool, which is only used for $0 . 2 \%$ of all examples, but mostly to the Wikipedia search and question answering tools.This makes sense given that entities in TEMPLAMA are often so specific and rare that even knowing the date alone would be of little help. The best course of action for this dataset – first querying the calendar API to get the current date, and then querying the QA system with this date – is not only prohibited by our restriction of using at most one API call, but also hard to learn for Toolformer given that all API calls in its training data are sampled independently. For DATESET, on the other hand, the considerable improvement of Toolformer compared to other models can be fully accredited to the calendar tool, which it makes use of for $5 4 . 8 \%$ of all examples.
+
+![](images/071c4fdbad1e77e8404f0631b4a51c5e303496f5cf70832da7e556306980604d.jpg)  
+Figure 4: Average performance on LAMA, our math benchmarks and our QA benchmarks for GPT-2 models of different sizes and GPT-J finetuned with our approach, both with and without API calls. While API calls are not helpful to the smallest models, larger models learn how to make good use of them. Even for bigger models, the gap between predictions with and without API calls remains high.
+
+# 4.3 Language Modeling
+
+We want to ensure that language modeling performance of Toolformer does not degrade through finetuning with API calls. To this end, we evaluate our models on two language modeling datasets: WikiText (Merity et al., 2017) and a subset of 10,000 randomly selected documents from CCNet (Wenzek et al., 2020) that were not used during training. Finetuning on CCNet leads to slightly improved performance on the CCNet evaluation subset (perplexity improves from 10.6 to 10.5), but slightly deteriorates performance on WikiText (9.9 to 10.3), presumably because the original pretraining data for GPT-J is more similar to WikiText than our subset of CCNet. Most importantly, however, training on $\mathcal { C } ^ { * }$ does not lead to an increase in perplexity compared to training on $\mathcal { C }$ when API calls are disabled at inference time, giving perplexities of 10.5 and 10.3, respectively.5
+
+# 4.4 Scaling Laws
+
+We investigate how the ability to ask external tools for help affects performance as we vary the size of our LM. To this end, we apply our approach not just to GPT-J, but also to four smaller models from the GPT-2 family (Radford et al., 2019), with 124M, 355M, 775M and 1.6B parameters, respectively. We do so using only a subset of three tools: the question answering system, the calculator, and the Wikipedia search engine. Apart from this, we follow the experimental setup described in Section 4.1. Figure 4 shows that the ability to leverage the provided tools only emerges at around 775M parameters: smaller models achieve similar performance both with and without tools. An exception to this is the Wikipedia search engine used mostly for QA benchmarks; we hypothesize that this is because the API is comparably easy to use. While models become better at solving tasks without API calls as they grow in size, their ability to make good use of the provided API improves at the same time. Thus, there remains a large gap between predictions with and without API calls even for our biggest model.
+
+In Appendix G, we extend these investigations in scale to the LLaMA v1 7B model (Touvron et al., 2023) to see how tool-use scales with model capability instead of size. We find that the utility of weaker tools such as the WikiSearch tool vanish for these stronger base-models, and we demonstrate the value of generating and scoring with a strong model, compared to simply finetuning.
+
+# 5 Related Work
+
+Language Model Pretraining There are various approaches that augment LMs with some form of additional textual information during pretraining, including various forms of metadata (Keskar et al., 2019), HTML tags (Aghajanyan et al., 2021), Wikipedia markup (Schick et al., 2022), or related texts obtained from an information retrieval system (Guu et al., 2020; Borgeaud et al., 2021; Izacard et al., 2022). For all of these approaches, additional information is always provided, regardless of whether it is helpful or not. In contrast, Toolformer learns for itself to explicitly asks for the right information.
+
+Tool Use Several approaches aim to equip LMs with the ability to use external tools such as search engines (Komeili et al., 2022; Thoppilan et al., 2022; Lazaridou et al., 2022; Shuster et al., 2022; Yao et al., 2022), web browsers (Nakano et al., 2021), calculators (Cobbe et al., 2021; Thoppilan et al., 2022), translation systems (Thoppilan et al., 2022) and Python interpreters (Gao et al., 2022). The way these models learn to use tools can roughly be divided into two approaches: Either they rely on large amounts of human supervision (Komeili et al., 2022; Nakano et al., 2021; Thoppilan et al., 2022) or they work by prompting the language model in a few-shot setup tailored towards a specific task where it is known a priori which tools needs to be used (Gao et al., 2022; Lazaridou et al., 2022; Yao et al., 2022). In contrast, the self-supervised nature of Toolformer enables it to learn how and when to use tools without requiring a specific prompt that shows task-specific examples of how a tool could be used. Perhaps most closely related to our work is TALM (Parisi et al., 2022), an approach that uses a similar self-supervised objective for teaching a model to use a calculator and a search engine, but explores this only in settings where a model is finetuned for downstream tasks.
+
+Bootstrapping The idea of using self-training and bootstrapping techniques to improve models has been investigated in various contexts, ranging from word sense disambiguation (Yarowsky, 1995), relation extraction (Brin, 1999; Agichtein and Gravano, 2000), parsing (McClosky et al., 2006), sequence generation (He et al., 2020), few-shot text classification (Schick and Schütze, 2021a) and retrieval (Izacard and Grave, 2021) to reasoning (Zelikman et al., 2022). In a similar spirit, Toolformer is trained on its own predictions after applying a perplexity-based filtering step.
+
+# 6 Limitations
+
+While our approach enables LMs to learn how to use a variety of tools in a self-supervised way, there are some clear limitations to what can be achieved with our method in its current form. One such limitation is the inability of Toolformer to use tools in a chain (i.e., using the output of one tool as an input for another tool). This is due to the fact that API calls for each tool are generated independently; as a consequence, there are no examples of chained tool use in the finetuning dataset, since this would necessitate multiple API calls per example. Our current approach also does not allow the LM to use a tool in an interactive way – especially for tools such as search engines, that could potentially return hundreds of different results, enabling a LM to browse through these results or to refine its search query in a similar spirit to Nakano et al. (2021) can be crucial for certain applications. Beyond this, we found models trained with Toolformer to often be sensitive to the exact wording of their input when deciding whether or not to call an API; this is perhaps unsurprising given that LMs are known to be very sensitive to the prompt they are provided with in both zero- and few-shot settings (Jiang et al., 2020; Schick and Schütze, 2021a). Depending on the tool, our method is also very sample-inefficient; for example, processing more than a million documents results in only a few thousand examples of useful calls to the calculator API. A potential solution to this problem might be to iteratively apply our approach, similar to how this is done in related bootstrapping approaches (Schick and Schütze, 2021a; Izacard and Grave, 2021; Parisi et al., 2022). Finally, when deciding whether or not to make an API call, Toolformer currently does not take into account the tool-dependent, computational cost incurred from making an API call.
+
+# 7 Conclusion
+
+We have introduced Toolformer, a LM that learns in a self-supervised way how to use different tools such as search engines, calculators, and translation systems via simple API calls. This is done by finetuning on sampled API calls that are filtered based on whether they reduce perplexity on future tokens. Toolformer considerably improves zero-shot performance of a 6.7B parameter GPT-J model, enabling it to even outperform a much larger GPT-3 model on a range of different downstream tasks.
+
+# References
+
+Armen Aghajanyan, Dmytro Okhonko, Mike Lewis, Mandar Joshi, Hu Xu, Gargi Ghosh, and Luke Zettlemoyer. 2021. Htlm: Hyper-text pre-training and prompting of language models.
+
+Eugene Agichtein and Luis Gravano. 2000. Snowball: Extracting relations from large plain-text collections. In Proceedings of the Fifth ACM Conference on Digital Libraries, DL ’00, page 85–94, New York, NY, USA. Association for Computing Machinery.
+
+Ricardo Baeza-Yates, Berthier Ribeiro-Neto, et al. 1999. Modern information retrieval, volume 463. ACM press New York.
+
+Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. 2013. Semantic parsing on Freebase from question-answer pairs. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pages 1533–1544, Seattle, Washington, USA. Association for Computational Linguistics.
+
+Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George van den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, Diego de Las Casas, Aurelia Guy, Jacob Menick, Roman Ring, Tom Hennigan, Saffron Huang, Loren Maggiore, Chris Jones, Albin Cassirer, Andy Brock, Michela Paganini, Geoffrey Irving, Oriol Vinyals, Simon Osindero, Karen Simonyan, Jack W. Rae, Erich Elsen, and Laurent Sifre. 2021. Improving language models by retrieving from trillions of tokens.
+
+Sergey Brin. 1999. Extracting patterns and relations from the world wide web. In The World Wide Web and Databases, pages 172–183, Berlin, Heidelberg. Springer Berlin Heidelberg.
+
+Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. 2020. Language models are few-shot learners. In Advances in Neural Information Processing Systems, volume 33, pages 1877–1901. Curran Associates, Inc.
+
+Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, Parker Schuh, Kensen Shi, Sasha Tsvyashchenko, Joshua Maynez, Abhishek Rao, Parker Barnes, Yi Tay, Noam Shazeer, Vinodkumar Prabhakaran, Emily Reif, Nan Du, Ben Hutchinson, Reiner Pope, James Bradbury, Jacob Austin, Michael Isard, Guy Gur-Ari, Pengcheng Yin, Toju Duke, Anselm Levskaya, Sanjay Ghemawat, Sunipa Dev, Henryk Michalewski, Xavier Garcia, Vedant Misra, Kevin Robinson, Liam Fedus, Denny Zhou, Daphne Ippolito, David Luan, Hyeontaek Lim, Barret Zoph, Alexander Spiridonov, Ryan Sepassi, David Dohan, Shivani Agrawal, Mark Omernick, Andrew M. Dai, Thanumalayan Sankaranarayana Pillai, Marie Pellat, Aitor Lewkowycz, Erica Moreira, Rewon Child, Oleksandr Polozov, Katherine Lee, Zongwei Zhou, Xuezhi Wang, Brennan Saeta, Mark Diaz, Orhan Firat, Michele Catasta, Jason Wei, Kathy Meier-Hellstern, Douglas Eck, Jeff Dean, Slav Petrov, and Noah Fiedel. 2022. Palm: Scaling language modeling with pathways.
+
+Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168.
+
+Marta R Costa-jussà, James Cross, Onur Çelebi, Maha Elbayad, Kenneth Heafield, Kevin Heffernan, Elahe Kalbassi, Janice Lam, Daniel Licht, Jean Maillard, et al. 2022. No language left behind: Scaling human-centered machine translation. arXiv preprint arXiv:2207.04672.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota. Association for Computational Linguistics.
+
+Bhuwan Dhingra, Jeremy R. Cole, Julian Martin Eisenschlos, Daniel Gillick, Jacob Eisenstein, and William W. Cohen. 2022. Time-aware language models as temporal knowledge bases. Transactions of the Association for Computational Linguistics, 10:257–273.
+
+Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. 2022. Pal: Program-aided language models.
+
+Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. 2020. Realm: Retrieval-augmented language model pre-training.
+
+Junxian He, Jiatao Gu, Jiajun Shen, and Marc’Aurelio Ranzato. 2020. Revisiting self-training for neural sequence generation. In International Conference on Learning Representations.
+
+Or Honovich, Thomas Scialom, Omer Levy, and Timo Schick. 2022. Unnatural instructions: Tuning language models with (almost) no human labor.
+
+Gautier Izacard and Edouard Grave. 2021. Distilling knowledge from reader to retriever for question answering. In International Conference on Learning Representations.
+
+Gautier Izacard, Patrick Lewis, Maria Lomeli, Lucas Hosseini, Fabio Petroni, Timo Schick, Jane Dwivedi-Yu, Armand Joulin, Sebastian Riedel, and Edouard Grave. 2022. Atlas: Few-shot learning with retrieval augmented language models.
+
+Ziwei Ji, Nayeon Lee, Rita Frieske, Tiezheng Yu, Dan Su, Yan Xu, Etsuko Ishii, Yejin Bang, Andrea Madotto, and Pascale Fung. 2022. Survey of hallucination in natural language generation. ACM Computing Surveys.
+
+Zhengbao Jiang, Frank F. Xu, Jun Araki, and Graham Neubig. 2020. How can we know what language models know? Transactions of the Association for Computational Linguistics, 8:423–438.
+
+Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. 2017. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1601–1611, Vancouver, Canada. Association for Computational Linguistics.
+
+Armand Joulin, Edouard Grave, Piotr Bojanowski, Matthijs Douze, Hérve Jégou, and Tomas Mikolov. 2016. Fasttext. zip: Compressing text classification models. arXiv preprint arXiv:1612.03651.
+
+Nitish Shirish Keskar, Bryan McCann, Lav R. Varshney, Caiming Xiong, and Richard Socher. 2019. Ctrl: A conditional transformer language model for controllable generation.
+
+Philipp Koehn. 2005. Europarl: A parallel corpus for statistical machine translation. In Proceedings of machine translation summit x: papers, pages 79–86.
+
+Mojtaba Komeili, Kurt Shuster, and Jason Weston. 2022. Internet-augmented dialogue generation. In Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 8460–8478, Dublin, Ireland. Association for Computational Linguistics.
+
+Rik Koncel-Kedziorski, Subhro Roy, Aida Amini, Nate Kushman, and Hannaneh Hajishirzi. 2016. MAWPS: A math word problem repository. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 1152–1157, San Diego, California. Association for Computational Linguistics.
+
+Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Jacob Devlin, Kenton Lee, Kristina Toutanova, Llion Jones, Matthew Kelcey, Ming-Wei Chang, Andrew M. Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. 2019. Natural questions: A benchmark for question answering research. Transactions of the Association for Computational Linguistics, 7:452–466.
+
+Angeliki Lazaridou, Elena Gribovskaya, Wojciech Stokowiec, and Nikolai Grigorev. 2022. Internetaugmented language models through few-shot prompting for open-domain question answering. arXiv preprint arXiv:2203.05115.
+
+Patrick Lewis, Barlas Oguz, Ruty Rinott, Sebastian Riedel, and Holger Schwenk. 2019. Mlqa:˘ Evaluating cross-lingual extractive question answering. arXiv preprint arXiv:1910.07475.
+
+Xi Victoria Lin, Todor Mihaylov, Mikel Artetxe, Tianlu Wang, Shuohui Chen, Daniel Simig, Myle Ott, Naman Goyal, Shruti Bhosale, Jingfei Du, Ramakanth Pasunuru, Sam Shleifer, Punit Singh Koura, Vishrav Chaudhary, Brian O’Horo, Jeff Wang, Luke Zettlemoyer, Zornitsa Kozareva, Mona Diab, Veselin Stoyanov, and Xian Li. 2021. Few-shot learning with multilingual language models.
+
+Joshua Maynez, Shashi Narayan, Bernd Bohnet, and Ryan McDonald. 2020. On faithfulness and factuality in abstractive summarization.
+
+David McClosky, Eugene Charniak, and Mark Johnson. 2006. Effective self-training for parsing. In Proceedings of the Human Language Technology Conference of the NAACL, Main Conference, pages 152–159, New York City, USA. Association for Computational Linguistics.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. 2017. Pointer sentinel mixture models. In International Conference on Learning Representations.
+
+Shen-yun Miao, Chao-Chun Liang, and Keh-Yih Su. 2020. A diverse corpus for evaluating and developing English math word problem solvers. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 975–984, Online. Association for Computational Linguistics.
+
+Reiichiro Nakano, Jacob Hilton, Suchir Balaji, Jeff Wu, Long Ouyang, Christina Kim, Christopher Hesse, Shantanu Jain, Vineet Kosaraju, William Saunders, Xu Jiang, Karl Cobbe, Tyna Eloundou, Gretchen Krueger, Kevin Button, Matthew Knight, Benjamin Chess, and John Schulman. 2021. Webgpt: Browser-assisted question-answering with human feedback.
+
+Aaron Parisi, Yao Zhao, and Noah Fiedel. 2022. Talm: Tool augmented language models.
+
+Arkil Patel, Satwik Bhattamishra, and Navin Goyal. 2021. Are NLP models really able to solve simple math word problems? In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 2080–2094, Online. Association for Computational Linguistics.
+
+Fabio Petroni, Aleksandra Piktus, Angela Fan, Patrick Lewis, Majid Yazdani, Nicola De Cao, James Thorne, Yacine Jernite, Vladimir Karpukhin, Jean Maillard, Vassilis Plachouras, Tim Rocktäschel, and Sebastian Riedel. 2021. KILT: a benchmark for knowledge intensive language tasks. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 2523–2544, Online. Association for Computational Linguistics.
+
+Fabio Petroni, Tim Rocktäschel, Sebastian Riedel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, and Alexander Miller. 2019. Language models as knowledge bases? In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 2463–2473, Hong Kong, China. Association for Computational Linguistics.
+
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. 2019. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9.
+
+Stephen E Robertson, Steve Walker, Susan Jones, Micheline M Hancock-Beaulieu, Mike Gatford, et al. 1995. Okapi at trec-3. Nist Special Publication Sp, 109:109.
+
+Timo Schick, Jane Dwivedi-Yu, Zhengbao Jiang, Fabio Petroni, Patrick Lewis, Gautier Izacard, Qingfei You, Christoforos Nalmpantis, Edouard Grave, and Sebastian Riedel. 2022. Peer: A collaborative language model.
+
+Timo Schick and Hinrich Schütze. 2021a. Exploiting cloze-questions for few-shot text classification and natural language inference. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 255–269, Online. Association for Computational Linguistics.
+
+Timo Schick and Hinrich Schütze. 2021b. Generating datasets with pretrained language models. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pages 6943–6951, Online and Punta Cana, Dominican Republic. Association for Computational Linguistics.
+
+Kurt Shuster, Jing Xu, Mojtaba Komeili, Da Ju, Eric Michael Smith, Stephen Roller, Megan Ung, Moya Chen, Kushal Arora, Joshua Lane, Morteza Behrooz, William Ngan, Spencer Poff, Naman Goyal, Arthur Szlam, Y-Lan Boureau, Melanie Kambadur, and Jason Weston. 2022. Blenderbot 3: a deployed conversational agent that continually learns to responsibly engage.
+
+Romal Thoppilan, Daniel De Freitas, Jamie Hall, Noam Shazeer, Apoorv Kulshreshtha, Heng-Tze Cheng, Alicia Jin, Taylor Bos, Leslie Baker, Yu Du, YaGuang Li, Hongrae Lee, Huaixiu Steven Zheng, Amin Ghafouri, Marcelo Menegali, Yanping Huang, Maxim Krikun, Dmitry Lepikhin, James Qin, Dehao Chen, Yuanzhong Xu, Zhifeng Chen, Adam Roberts, Maarten Bosma, Vincent Zhao, Yanqi Zhou, Chung-Ching Chang, Igor Krivokon, Will Rusch, Marc Pickett, Pranesh Srinivasan, Laichee Man, Kathleen Meier-Hellstern, Meredith Ringel Morris, Tulsee Doshi, Renelito Delos Santos, Toju Duke, Johnny Soraker, Ben Zevenbergen, Vinodkumar Prabhakaran, Mark Diaz, Ben Hutchinson, Kristen Olson, Alejandra Molina, Erin Hoffman-John, Josh Lee, Lora Aroyo, Ravi Rajakumar, Alena Butryna, Matthew Lamm, Viktoriya Kuzmina, Joe Fenton, Aaron Cohen, Rachel Bernstein, Ray Kurzweil, Blaise Aguera-Arcas, Claire Cui, Marian Croak, Ed Chi, and Quoc Le. 2022. Lamda: Language models for dialog applications.
+
+Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, Aurelien Rodriguez, Armand Joulin, Edouard Grave, and Guillaume Lample. 2023. Llama: Open and efficient foundation language models.
+
+Ben Wang and Aran Komatsuzaki. 2021. GPT-J-6B: A 6 Billion Parameter Autoregressive Language Model. https://github.com/kingoflolz/mesh-transformer-jax.
+
+Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A. Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2022. Self-instruct: Aligning language model with self generated instructions.
+
+Guillaume Wenzek, Marie-Anne Lachaux, Alexis Conneau, Vishrav Chaudhary, Francisco Guzmán, Armand Joulin, and Edouard Grave. 2020. CCNet: Extracting high quality monolingual datasets from web crawl data. In Proceedings of the Twelfth Language Resources and Evaluation Conference, pages 4003–4012, Marseille, France. European Language Resources Association.
+
+Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models.
+
+David Yarowsky. 1995. Unsupervised word sense disambiguation rivaling supervised methods. In 33rd Annual Meeting of the Association for Computational Linguistics, pages 189–196, Cambridge, Massachusetts, USA. Association for Computational Linguistics.
+
+Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah D. Goodman. 2022. Star: Bootstrapping reasoning with reasoning.
+
+Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen, Christopher Dewan, Mona Diab, Xian Li, Xi Victoria Lin, Todor Mihaylov, Myle Ott, Sam Shleifer, Kurt Shuster, Daniel Simig, Punit Singh Koura, Anjali Sridhar, Tianlu Wang, and Luke Zettlemoyer. 2022. Opt: Open pre-trained transformer language models.

parse/dev/Yacmpz84TH/Yacmpz84TH_content_list.json

@@ -0,0 +1,1502 @@
+[
+    {
+        "type": "text",
+        "text": "Toolformer: Language Models Can Teach Themselves to Use Tools ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            122,
+            823,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Timo Schick Jane Dwivedi-Yu Roberto Dessì† Roberta Raileanu Maria Lomeli Eric Hambro Luke Zettlemoyer Nicola Cancedda Thomas Scialom ",
+        "bbox": [
+            183,
+            224,
+            816,
+            260
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "FAIR, Meta †Universitat Pompeu Fabra ",
+        "bbox": [
+            366,
+            268,
+            632,
+            284
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            319,
+            535,
+            337
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Language models (LMs) exhibit remarkable abilities to solve new tasks from just a few examples or textual instructions, especially at scale. They also, paradoxically, struggle with basic functionality, such as arithmetic or factual lookup, where much simpler and smaller specialized models excel. In this paper, we show that LMs can teach themselves to use external tools via simple APIs and achieve the best of both worlds. We introduce Toolformer, a model trained to decide which APIs to call, when to call them, what arguments to pass, and how to best incorporate the results into future token prediction. This is done in a self-supervised way, requiring nothing more than a handful of demonstrations for each API. We incorporate a range of tools, including a calculator, a Q&A system, a search engine, a translation system, and a calendar. Toolformer achieves substantially improved zero-shot performance across a variety of downstream tasks, often competitive with much larger models, without sacrificing its core language modeling abilities. ",
+        "bbox": [
+            233,
+            349,
+            766,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            551,
+            310,
+            569
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Large language models achieve impressive zero and few-shot results on a variety of natural language processing tasks (Brown et al., 2020; Chowdhery et al., 2022, i.a.). However, these models have several inherent limitations that can at best be partially addressed by further scaling. These limitations include an inability to access up-to-date information on recent events (Komeili et al., 2022) and the related tendency to hallucinate facts (Maynez et al., 2020; Ji et al., 2022), difficulties in understanding low-resource languages (Lin et al., 2021), a lack of mathematical skills to perform precise calculations (Patel et al., 2021) and an unawareness of the progression of time (Dhingra et al., 2022). ",
+        "bbox": [
+            174,
+            582,
+            825,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A simple way to overcome the limitations of today’s language models is to give them the ability to use external tools such as search engines, calculators, or calendars. However, existing approaches either rely on large amounts of human annotations (Komeili et al., 2022; Thoppilan et al., 2022) or limit tool use to task-specific settings only (e.g., Gao et al., 2022; Parisi et al., 2022), hindering a more widespread adoption of tool use in LMs. Therefore, we propose Toolformer, a model that learns to use tools in a novel way, which fulfills the following desiderata: ",
+        "bbox": [
+            176,
+            685,
+            825,
+            768
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Tool use should be learned in a self-supervised way without large amounts of human annotations. This is important not only because of the costs associated with such annotations, but also because what humans find useful may be different from what a model finds useful. • The LM should not lose any of its generality and should be able to decide for itself when and how to use which tool. In contrast to existing approaches, this enables a much more comprehensive use of tools that is not tied to specific tasks. ",
+        "bbox": [
+            217,
+            779,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our approach for achieving these goals is based on the recent idea of using large LMs with in-context learning (Brown et al., 2020) to generate entire datasets from scratch (Schick and Schütze, 2021b; ",
+        "bbox": [
+            173,
+            876,
+            823,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/efd2dac35f6d1a63826328723565885e1aad2ceea0a3379b92e4c40bd9922f6b.jpg",
+        "image_caption": [
+            "Figure 1: Exemplary predictions of Toolformer. The model autonomously decides to call different APIs (from top to bottom: a question answering system, a calculator, a machine translation system, and a Wikipedia search engine) to obtain information that is useful for completing a piece of text. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            823,
+            231
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/5869d239001ffcca88eb10a98a653d9f154d0247150188f33783d20eda69ab5b.jpg",
+        "image_caption": [
+            "Figure 2: Key steps in ourwe first sample a position pproach, illustrated for a question answe and corresponding API call candidates en an input text . We then execu $\\mathbf { x }$ , $i$ $c _ { i } ^ { 1 } , c _ { i } ^ { 2 } , \\ldots , c _ { i } ^ { k }$ these API calls and filter out all calls which do not reduce the loss $L _ { i }$ over the next tokens. All remaining API calls are interleaved with the original text, resulting in a new text $\\mathbf { x } ^ { * }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            304,
+            825,
+            406
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Honovich et al., 2022; Wang et al., 2022): Given just a handful of human-written examples of how an API can be used, we let a LM annotate a huge language modeling dataset with potential API calls. We then use a self-supervised loss to determine which of these API calls actually help the model in predicting future tokens. Finally, we finetune the LM itself on the API calls that it considers useful. As illustrated in Figure 1, through this simple approach, LMs can learn to control a variety of tools, and to choose for themselves which tool to use when and how. ",
+        "bbox": [
+            173,
+            497,
+            826,
+            582
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As our approach is agnostic of the dataset being used, we can apply it to the exact same dataset that was used to pretrain a model in the first place. This ensures that the model does not lose any of its generality and language modeling abilities. We conduct experiments on a variety of different downstream tasks, demonstrating that after learning to use tools, Toolformer, which is based on a pretrained GPT-J model (Wang and Komatsuzaki, 2021) with 6.7B parameters, achieves much stronger zero-shot results, clearly outperforming a much larger GPT-3 model (Brown et al., 2020) and several other baselines on various tasks. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            685
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Approach ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            707,
+            289,
+            724
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our aim is to equip a language model $M$ with the ability to use different tools through API calls. We represent API calls as tuples $c = ( a _ { c } , i _ { c } )$ where $a _ { c }$ is the name of the API and $i _ { c }$ is the corresponding input. Given an API call $c$ with a corresponding result $r$ , we denote the linearized sequences of the API call not including and including its result, respectively, as: ",
+        "bbox": [
+            173,
+            739,
+            825,
+            795
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1064527a7674ba25a1414da0a4003e59afc6210588e374a16176efe73e849733.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathsf { e } ( c ) = < \\mathtt { A P I } > a _ { c } ( i _ { c } ) < / \\mathtt { A P I } > \\mathsf { e } ( c , r ) = < \\mathtt { A P I } > a _ { c } ( i _ { c } ) \\to r < / \\mathtt { A P I } > } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            804,
+            751,
+            821
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $ { \\mathrm { ~  ~ \\cdots ~ } } < \\tt { A P I } >  { \\mathrm { ^ { \\circ } } }$ , $ { \\mathrm { ~  ~ \\cdots ~ } } < / \\tt A P I >  { \\mathrm { ^ { \\circ } } }$ and $\\ \"  \\ \"$ are special tokens.1 Some examples of linearized API calls inserted into text sequences are shown in Figure 1. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            858
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Your task is to add calls to a Question Answering API to a piece of text. The questions should help you get information required to complete the text. You can call the API by writing \"[QA(question)]\" where \"question\" is the question you want to ask. Here are some examples of API calls: ",
+        "bbox": [
+            183,
+            95,
+            812,
+            135
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input: Joe Biden was born in Scranton, Pennsylvania.   \nOutput: Joe Biden was born in [QA(\"Where was Joe Biden born?\")] Scranton, [QA(\"In which state is Scranton?\")] Pennsylvania. ",
+        "bbox": [
+            181,
+            143,
+            750,
+            183
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input: Coca-Cola, or Coke, is a carbonated soft drink manufactured by the Coca-Cola Company. Output: Coca-Cola, or [QA(\"What other name is Coca-Cola known by?\")] ${ \\mathsf { C o k e } } ,$ , is a carbonated soft drink manufactured by [QA(\"Who manufactures Coca-Cola?\")] the Coca-Cola Company. ",
+        "bbox": [
+            184,
+            193,
+            802,
+            232
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input: x Output: ",
+        "bbox": [
+            184,
+            241,
+            227,
+            266
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a dataset $\\mathcal { C } = \\{ \\mathbf { x } ^ { 1 } , \\ldots , \\mathbf { x } ^ { | \\mathcal { C } | } \\}$ of plain texts, we first convert this dataset into a dataset $\\mathcal { C } ^ { * }$ augmented with API calls. This is done in three steps, illustrated in Figure 2: First, we exploit the in-context learning ability of $M$ to sample a large number of API calls. We then execute them and finally check whether the obtained responses are helpful for predicting future tokens; this is used as a filtering criterion. After filtering, we merge API calls for different tools, resulting in the augmented dataset $\\mathcal { C } ^ { * }$ , and finetune $M$ itself on this dataset. Each step is described in more detail below. ",
+        "bbox": [
+            173,
+            316,
+            825,
+            402
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Sampling API Calls For each API, we write a prompt $P ( \\mathbf { x } )$ that encourages the LM to annotate an example $\\mathbf { x } = x _ { 1 } , \\ldots , x _ { n }$ with API calls. An example of such a prompt for a question answering tool is shown in Figure 3. Let $p _ { M } ( z _ { n + 1 } \\mid z _ { 1 } , . . . , z _ { n } )$ be the probability that $M$ assigns to token $z _ { n + 1 }$ as a continuation for the sequence $z _ { 1 } , \\ldots , z _ { n }$ . We first sample up to $k$ candidate positions for doing API calls by computing, for each $i \\in \\{ 1 , \\ldots , n \\}$ , the probability $p _ { i } = p _ { M } ( < _ { \\tt A P I > } \\mid P ( \\mathbf { x } ) , x _ { 1 : i - 1 } )$ that $M$ assigns to starting an API call at position $i$ . Given a sampling threshold $\\tau _ { s }$ , we keep all positions $I \\stackrel { - } { = } \\{ i | p _ { i } > \\tau _ { s } \\stackrel { - } { \\} }$ ; if there are more than $k$ such positions, we only keep the top $k$ . For each position $i \\in I$ , we then obtain up to $m$ API calls $c _ { i } ^ { 1 } , \\ldots , c _ { i } ^ { m }$ by sampling from $M$ given the sequence $[ P ( \\mathbf { x } ) , x _ { 1 } , \\ldots , x _ { i - 1 } , < \\mathtt { A P I } > ]$ as a prefix and ${ < } / { \\tt A P I > }$ as an end-of-sequence token. ",
+        "bbox": [
+            173,
+            415,
+            825,
+            541
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Executing API Calls As a next step, we execute all API calls generated by $M$ . How this is done depends entirely on the API itself – for example, it can involve calling another neural network, executing a Python script or using a retrieval system to perform search over a large corpus. The response for each API call $c _ { i }$ needs to be a single text sequence $r _ { i }$ . ",
+        "bbox": [
+            174,
+            554,
+            825,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Filtering API Calls Let $i$ be the position of the API call $c _ { i }$ in the sequence $\\mathbf { x } = x _ { 1 } , \\ldots , x _ { n }$ , and let $r _ { i }$ be the response from the API. Further, given a sequence $( w _ { i } \\mid i \\in \\mathbb { N } )$ of weights, let ",
+        "bbox": [
+            174,
+            623,
+            823,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33953fde96b6483fae55868512e0984f9f0c88054ed8aa8da92f9a5865ced994.jpg",
+        "text": "$$\nL _ { i } ( \\mathbf { z } ) = - \\sum _ { j = i } ^ { n } w _ { j - i } \\cdot \\log p _ { M } ( x _ { j } \\mid \\mathbf { z } , x _ { 1 : j - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            656,
+            648,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "be the weighted cross entropy loss for $M$ over the tokens $x _ { i } , \\ldots , x _ { n }$ if the model is prefixed with some text sequence $\\mathbf { z }$ . We compare two different instantiations of this loss: ",
+        "bbox": [
+            169,
+            702,
+            823,
+            729
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61abd2850c8d5910556db651b3401e55160ad88007a179cdad0a9c344439d1f2.jpg",
+        "text": "$$\nL _ { i } ^ { + } = L _ { i } ( \\mathbf { e } ( c _ { i } , r _ { i } ) ) \\qquad L _ { i } ^ { - } = \\operatorname* { m i n } \\left( L _ { i } ( \\varepsilon ) , L _ { i } ( \\mathbf { e } ( c _ { i } , \\varepsilon ) ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            732,
+            699,
+            750
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\varepsilon$ denotes an empty sequence. The former is the weighted loss over all tokens $x _ { i } , \\ldots , x _ { n }$ if the API call and its result are given to $M$ as a prefix;2 the latter is the minimum of the losses obtained from (i) doing no API call at all and (ii) doing an API call, but not providing the response. Intuitively, an API call is helpful to $M$ if providing it with both the input and the output of this call makes it easier for the model to predict future tokens, compared to not receiving the API call at all, or receiving only its input. Given a filtering threshold $\\tau _ { f }$ , we thus only keep API calls for which $L _ { i } ^ { - } - L _ { i } ^ { + } \\ge \\tau _ { f }$ holds, i.e., adding the API call and its result reduces the loss by at least $\\tau _ { f }$ , compared to not doing any API call or obtaining no result from it. ",
+        "bbox": [
+            173,
+            752,
+            826,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/cc2e355eee41244dc7e1460c8b1bc8ba42ead9d5d51d4666ba28b5eaec959037.jpg",
+        "table_caption": [
+            "Table 1: Examples of inputs and outputs for all APIs used. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>API Name</td><td>Example Input</td><td>Example Output</td></tr><tr><td>Question Answering</td><td>Where was the Knights of Columbus founded?</td><td>New Haven, Connecticut</td></tr><tr><td>Wikipedia Search</td><td>Fishing Reel Types</td><td>Spin fishing &gt; Spin fishing is distinguished between fly fishing and bait cast fishing by the type of rod and reel used. There are two types of reels used when spin fishing,</td></tr><tr><td>Calculator</td><td>27+4*2</td><td>the open faced reel and the closed faced reel. 35</td></tr><tr><td>Calendar</td><td>m</td><td>Today is Monday, January 30,2023.</td></tr><tr><td>Machine Translation</td><td>sureté nucléaire</td><td>nuclear safety</td></tr></table>",
+        "bbox": [
+            173,
+            111,
+            821,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Model Finetuning After sampling and filtering calls for all APIs, we finally merge the remaining API calls and interleave them with the original inputs. That is, for an input text $\\mathbf { x } = x _ { 1 } , \\ldots , x _ { n }$ with a corresponding API call and result $( c _ { i } , r _ { i } )$ at position $i$ , we construct the new sequence $\\mathbf { x } ^ { * } = x _ { 1 : i - 1 } , \\mathbf { e } ( c _ { i } , r _ { i } ) , x _ { i : n }$ ; we proceed analogously for texts with multiple API calls. Doing this for all $\\mathbf { x } \\in { \\mathcal { C } }$ results in the new dataset $\\mathcal { C } ^ { * }$ augmented with API calls. We use $\\mathcal { C } ^ { * }$ to finetune $M$ , using a standard language modeling objective. Crucially, apart from inserted API calls, $\\mathcal { C } ^ { * }$ contains the exact same texts as $\\mathcal { C }$ , the original dataset. As a consequence, finetuning $M$ on $\\mathcal { C } ^ { * }$ exposes it to the same content as finetuning on $\\mathcal { C }$ . Moreover, as API calls are inserted in exactly those positions and with exactly those inputs that help $M$ predict future tokens, finetuning on $\\mathcal { C } ^ { * }$ enables the language model to decide when and how to use which tool, based purely on its own feedback. ",
+        "bbox": [
+            173,
+            276,
+            825,
+            415
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inference When generating text with $M$ after finetuning with our approach, we perform regular decoding until $M$ produces the $\\ \"  \\ \"$ token, indicating that it next expects the response for an API call. At this point, we interrupt the decoding process, call the appropriate API to get a response, and continue the decoding process after inserting both the response and the ${ < } / \\tt { A P I > }$ token. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Tools ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            503,
+            250,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We explore various tools to address different shortcomings of LMs. The only constraints we impose are that (i) their inputs and outputs can be represented as texts, and (ii) we can obtain a few demonstrations of their intended use. Concretely, we explore a question answering system, a Wikipedia search engine, a calculator, a calendar, and a machine translation system. Examples for the APIs associated with each of these tools are shown in Table 1. We briefly discuss all tools below. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Question Answering Our first tool is a question answering system based on another LM that can answer simple factoid questions. Specifically, we use Atlas (Izacard et al., 2022), a retrievalaugmented LM finetuned on Natural Questions (Kwiatkowski et al., 2019). ",
+        "bbox": [
+            176,
+            617,
+            823,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Calculator As a second tool, we use a calculator that can perform simple numeric calculations; we only support the four basic arithmetic operations. Results are always rounded to two decimal places. ",
+        "bbox": [
+            176,
+            674,
+            823,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Wikipedia Search Our third tool is a search engine that, given a search term, returns short text snippets from Wikipedia. Compared to our question answering tool, this search enables a model to get more comprehensive information on a subject, but requires it to extract the relevant parts by itself. As our search engine, we use a BM25 retriever (Robertson et al., 1995; Baeza-Yates et al., 1999) that indexes the Wikipedia dump from KILT (Petroni et al., 2021). ",
+        "bbox": [
+            174,
+            715,
+            825,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Machine Translation System Our fourth tool is a machine translation system based on a LM that can translate a phrase from any language into English. More concretely, we use the 600M parameter NLLB (Costa-jussà et al., 2022) as our multilingual machine translation model that works for 200 languages (including low-resource ones). The source language is automatically detected using the fastText classifier (Joulin et al., 2016), while the target language is always set to English. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            869
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Calendar Our final tool is a calendar API that, when queried, returns the current date without taking any input. This provides temporal context for predictions that require some awareness of time. ",
+        "bbox": [
+            173,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/6ff4b55b4a07eedc3b46aca4392f355c7700e2c3c0ae697c3d7df3dcacc10adc.jpg",
+        "table_caption": [
+            "Table 2: Number of examples with API calls in $\\mathcal { C } ^ { * }$ for different values of our filtering threshold $\\tau _ { f }$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Number of Examples</td></tr><tr><td>API</td><td>Tf = 0.5</td><td>Tf = 1.0</td><td>Tf = 2.0</td></tr><tr><td>Question Answering</td><td>51,987</td><td>18,526</td><td>5,135</td></tr><tr><td>Wikipedia Search</td><td>207,241</td><td>60,974</td><td>13,944</td></tr><tr><td>Calculator</td><td>3,680</td><td>994</td><td>138</td></tr><tr><td>Calendar</td><td>61,811</td><td>20,587</td><td>3,007</td></tr><tr><td>Machine Translation</td><td>3,156</td><td>1,034</td><td>229</td></tr></table>",
+        "bbox": [
+            285,
+            111,
+            712,
+            217
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            312,
+            256
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We investigate whether our approach enables a LM to use tools without any further supervision and to decide for itself when and how to call which tool. To test this, we select a variety of downstream tasks where we assume at least one of the considered tools to be useful, and evaluate performance in zero-shot settings (Section 4.2). Beyond that, we also ensure that our approach does not hurt the model’s core LM abilities; we verify this by looking at perplexity on two language modeling datasets (Section 4.3). Finally, we investigate how tool use is affected by model size (Section 4.4). ",
+        "bbox": [
+            173,
+            268,
+            825,
+            353
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            369,
+            352,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use a subset of CCNet (Wenzek et al., 2020) as our dataset $\\mathcal { C }$ and GPT-J (Wang and Komatsuzaki, 2021) as our language model $M$ . To reduce the computational cost of annotating $\\mathcal { C }$ with API calls, we define heuristics for some APIs to get a subset of $\\mathcal { C }$ for which API calls are more likely to be helpful than for an average text. For example, we only consider texts for the calculator tool if they contain at least three numbers. Details of the heuristics used are given in Appendix A. For obtaining $\\mathcal { C } ^ { * }$ from $\\mathcal { C }$ , we perform all steps described in Section 2 and additionally filter out all examples for which all API calls were eliminated in the filtering step.3 For the weighting function, we use ",
+        "bbox": [
+            173,
+            393,
+            826,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/693c7b513b012950d4b380ba5c92ef3e8dbdb80d0fcf63a938802cc828f5b1e0.jpg",
+        "text": "$$\nw _ { t } = \\frac { \\tilde { w } _ { t } } { \\sum _ { s \\in \\mathbb { N } } \\tilde { w } _ { s } } \\mathrm { ~ w i t h ~ } \\tilde { w } _ { t } = \\operatorname* { m a x } ( 0 , 1 - 0 . 2 \\cdot t )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            497,
+            653,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "to make sure that API calls happen close to where the information provided by the API is actually helpful for the model. The thresholds $\\tau _ { s }$ and $\\tau _ { f }$ are chosen individually for each tool to ensure a sufficient number of examples; see Appendix A for details. Table 2 shows relevant statistics of our final dataset augmented with API calls. We finetune $M$ on $\\mathcal { C } ^ { * }$ using a batch size of 128 and a learning rate of $1 \\cdot 1 0 ^ { - 5 }$ with linear warmup for the first $10 \\%$ of training. Finetuning details are given in Appendix B. In our experiments, we mainly compare GPT-J and the following models: ",
+        "bbox": [
+            174,
+            536,
+            825,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• GPT- $\\mathbf { J } + \\mathbf { C } \\mathbf { C }$ : GPT-J finetuned on $\\mathcal { C }$ , our subset of CCNet without any API calls. • Toolformer: GPT-J finetuned on $\\mathcal { C } ^ { * }$ , our subset of CCNet augmented with API calls. • Toolformer (disabled): The same model as Toolformer, but API calls are disabled during decoding. This is achieved by manually setting the probability of the ${ \\tt { < A P I > } }$ token to 0. ",
+        "bbox": [
+            212,
+            631,
+            826,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We additionally compare to OPT (66B) (Zhang et al., 2022) and the original davinci variant of GPT-3 (175B) (Brown et al., 2020), two models that are about 10 and 25 times larger than GPT-J. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            738
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Downstream Tasks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            753,
+            344,
+            768
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate on various downstream tasks considering a prompted zero-shot setup: Models are instructed to solve each task in natural language (see Appendix C), but we provide no examples. This is in contrast to prior work on tool use (e.g., Gao et al., 2022; Parisi et al., 2022), where models are provided with dataset-specific examples of how a tool can be used to solve a concrete task. We choose this more challenging setup as we are interested in seeing whether Toolformer works in precisely those cases where a user does not specify in advance which tools should be used in which way. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/1fef6447578dea8a84f5206305726e82e0779b81f1fad138b9cbcd028bedaee7.jpg",
+        "table_caption": [
+            "Table 3: Results on subsets of LAMA and various benchmarks requiring mathematical reasoning. For LAMA, Toolformer uses the question answering tool for most examples, clearly outperforming all baselines of the same size and achieving results competitive with GPT-3. For the math benchmarks, Toolformer makes extensive use of the calculator tool, clearly outperforming OPT and GPT-3. Best results with a GPT-J based model are shown in bold, best results overall are underlined. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">LAMA</td><td colspan=\"3\">Math Benchmarks</td></tr><tr><td>Model</td><td>SQuAD</td><td>Google-RE</td><td>T-REx</td><td>ASDiv</td><td>SVAMP</td><td>MAWPS</td></tr><tr><td>GPT-J</td><td>17.8</td><td>4.9</td><td>31.9</td><td>7.5</td><td>5.2</td><td>9.9</td></tr><tr><td>GPT-J + CC</td><td>19.2</td><td>5.6</td><td>33.2</td><td>9.6</td><td>5.0</td><td>9.3</td></tr><tr><td>Toolformer (disabled)</td><td>22.1</td><td>6.3</td><td>34.9</td><td>14.8</td><td>6.3</td><td>15.0</td></tr><tr><td>Toolformer</td><td>33.8</td><td>11.5</td><td>53.5</td><td>40.4</td><td>29.4</td><td>44.0</td></tr><tr><td>OPT (66B)</td><td>21.6</td><td>2.9</td><td>30.1</td><td>6.0</td><td>4.9</td><td>7.9</td></tr><tr><td>GPT-3 (175B)</td><td>26.8</td><td>7.0</td><td>39.8</td><td>14.0</td><td>10.0</td><td>19.8</td></tr></table>",
+        "bbox": [
+            173,
+            165,
+            825,
+            296
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use greedy decoding, but with one modification for Toolformer: We let the model start an API call whenever ${ \\tt { < A P I > } }$ is one of the $k$ most likely tokens. For $k = 1$ , this corresponds to regular greedy decoding; we instead use $k = 1 0$ to increase the disposition of our model to make use of APIs. At the same time, we allow at most one API call per input to make sure the model does not get stuck in a loop where it constantly calls APIs. The effect of these modifications is explored in Appendix E. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            392
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "LAMA We evaluate our models on the SQuAD, Google-RE and T-REx subsets of the LAMA benchmark (Petroni et al., 2019). For each of these subsets, the task is to complete a short statement with a missing fact (e.g., a date or a place). As LAMA was originally designed to evaluate masked LMs (e.g., Devlin et al., 2019), we filter out examples where the mask token is not the final token, so that all examples can be processed in a left-to-right fashion. To account for different tokenizations and added complexity from not informing the model that a single word is required, for all models we use a slightly more lenient evaluation criterion than exact match and simply check whether the correct word is within the first five words predicted by the model. As LAMA is based on statements obtained directly from Wikipedia, we prevent Toolformer from using the Wikipedia Search API to avoid giving it an unfair advantage. As shown in Table 3 (left), all GPT-J models without tool use achieve similar performance. Crucially, Toolformer clearly outperforms these baseline models, improving upon the best baseline by 11.7, 5.2 and 18.6 points, respectively. It also clearly outperforms OPT (66B) and GPT-3 (175B), despite both models being much larger. This is achieved because the model independently decides to ask the question answering tool for the required information in almost all cases $( 9 8 . 1 \\% )$ ; for only very few examples, it uses a different tool $( 0 . 7 \\% )$ or no tool at all $( 1 . 2 \\% )$ . ",
+        "bbox": [
+            173,
+            410,
+            825,
+            617
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Math Benchmarks We test mathematical abilities on ASDiv (Miao et al., 2020), SVAMP (Patel et al., 2021) and the MAWPS benchmark (Koncel-Kedziorski et al., 2016). We again account for the fact that we test all models in a zero-shot setup by using a more lenient evaluation criterion: As the required output is always a number, we simply check for the first number predicted by the model.4 Results are shown in Table 3 (right). While GPT-J and GPT- $\\mathbf { J } + \\mathbf { C } \\mathbf { C }$ perform about the same, Toolformer achieves stronger results even without API calls. We surmise that this is because the model is finetuned on many examples of API calls and their results, improving its own mathematical capabilities. Nonetheless, allowing the model to make API calls more than doubles performance for all tasks, and also clearly outperforms the much larger OPT and GPT-3. This is because across all benchmarks, for $9 7 . 9 \\%$ of all examples the model decides to ask the calculator tool for help. ",
+        "bbox": [
+            173,
+            633,
+            825,
+            772
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Question Answering We look at Web Questions (Berant et al., 2013), Natural Questions (Kwiatkowski et al., 2019) and TriviaQA (Joshi et al., 2017). For evaluation, we check whether the first 20 words predicted by a model contain the correct answer instead of requiring an exact match. For Toolformer, we disable the question answering tool as this would make solving the tasks trivial. Results are shown in Table 4 (left). Once again, Toolformer clearly outperforms all other models based on GPT-J, relying on the Wikipedia search API $( 9 9 . 3 \\% )$ to find relevant information. However, ",
+        "bbox": [
+            173,
+            787,
+            825,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/88955ebdedb1c7b1fb16844885f092bc7abdad8acfc0aff3dec93eecff42ad5b.jpg",
+        "table_caption": [
+            "Table 4: Results for various question answering datasets and temporal datasets. Using the Wikipedia search tool for most examples, Toolformer clearly outperforms baselines of the same size, but falls short of GPT-3 (175B) for question answering tasks. For temporal datasets, Toolformer outperforms all baselines, but does not make use of the calendar tool for TEMPLAMA. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">LAMA</td><td colspan=\"2\">Temporal Datasets</td></tr><tr><td>Model</td><td>WebQS</td><td>NQ</td><td>TriviaQA</td><td>TEMPLAMA</td><td>DATESET</td></tr><tr><td>GPT-J</td><td>18.5</td><td>12.8</td><td>43.9</td><td>13.7</td><td>3.9</td></tr><tr><td>GPT-J + CC</td><td>18.4</td><td>12.2</td><td>45.6</td><td>12.9</td><td>2.9</td></tr><tr><td>Toolformer (disabled)</td><td>18.9</td><td>12.6</td><td>46.7</td><td>12.7</td><td>5.9</td></tr><tr><td>Toolformer</td><td>26.3</td><td>17.7</td><td>48.8</td><td>16.3</td><td>27.3</td></tr><tr><td>OPT (66B)</td><td>18.6</td><td>11.4</td><td>45.7</td><td>14.5</td><td>1.3</td></tr><tr><td>GPT-3 (175B)</td><td>29.0</td><td>22.6</td><td>65.9</td><td>15.5</td><td>0.8</td></tr></table>",
+        "bbox": [
+            204,
+            152,
+            794,
+            284
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8e2f305ae0827226a88158db7e15e5d91a20aa35a135b4771feca48d72e546b5.jpg",
+        "table_caption": [
+            "Table 5: Results on MLQA for Spanish (Es), German (De), Hindi $\\mathrm { ( H i ) }$ , Vietnamese (Vi), Chinese (Zh) and Arabic (Ar). While using the MT tool to translate questions is helpful across all languages, further pretraining on CCNet deteriorates performance; thus, Toolformer does not consistently outperform GPT-J. The final rows correspond to models that are given contexts and questions in English. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Es</td><td>De</td><td>Hi</td><td>Vi</td><td>Zh</td><td>Ar</td></tr><tr><td>GPT-J</td><td>15.2</td><td>16.5</td><td>1.3</td><td>8.2</td><td>18.2</td><td>8.2</td></tr><tr><td>GPT-J + CC</td><td>15.7</td><td>14.9</td><td>0.5</td><td>8.3</td><td>13.7</td><td>4.6</td></tr><tr><td>Toolformer (disabled)</td><td>19.8</td><td>11.9</td><td>1.2</td><td>10.1</td><td>15.0</td><td>3.1</td></tr><tr><td>Toolformer</td><td>20.6</td><td>13.5</td><td>1.4</td><td>10.6</td><td>16.8</td><td>3.7</td></tr><tr><td>OPT (66B)</td><td>0.3</td><td>0.1</td><td>1.1</td><td>0.2</td><td>0.7</td><td>0.1</td></tr><tr><td>GPT-3 (175B)</td><td>3.4</td><td>1.1</td><td>0.1</td><td>1.7</td><td>17.7</td><td>0.1</td></tr><tr><td>GPT-J (All En)</td><td>24.3</td><td>27.0</td><td>23.9</td><td>23.3</td><td>23.1</td><td>23.6</td></tr><tr><td>GPT-3 (All En)</td><td>24.7</td><td>27.2</td><td>26.1</td><td>24.9</td><td>23.6</td><td>24.0</td></tr></table>",
+        "bbox": [
+            269,
+            361,
+            728,
+            505
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Toolformer still lags behind the much larger GPT-3 (175B) model. This is likely due to both the simplicity of our search engine (in many cases, it returns results that are clearly not a good match for a given query) and the inability of Toolformer to interact with it, e.g., by reformulating its query if results are not helpful or by browsing through multiple of the top results. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            587
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Multilingual QA We evaluate all models on MLQA (Lewis et al., 2019), a multilingual QA benchmark. Context for each question is provided in English, while the question can be in Arabic, German, Spanish, Hindi, Vietnamese, or Simplified Chinese. Our evaluation metric is the percentage of times the model’s generation, capped at 10 words, contains the correct answer. Results are shown in Table 5. API calls improve Toolformer’s performance for all languages, suggesting that it has learned to make use of the machine translation tool. Depending on the language, this tool is used for $6 3 . 8 \\%$ to $9 4 . 9 \\%$ of all examples; the only exception is Hindi, for which it is used in only $7 . 3 \\%$ of cases. However, Toolformer does not consistently outperform GPT-J as finetuning on CCNet deteriorates performance for some languages. OPT and GPT-3 perform surprisingly weak across all languages, mostly because they fail to provide an answer in English despite being instructed to do so. A potential reason for GPT-J not suffering from this problem is that it was trained on more multilingual data than both OPT and GPT-3, including EuroParl (Koehn, 2005). As an upper bound, we also evaluate GPT-J and GPT-3 on a variant of MLQA where both the context and the question are provided in English. In this setup, GPT-3 performs better than all other models, supporting our hypothesis that its subpar performance on MLQA is due to the task’s multilingual aspect. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            811
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Temporal Datasets We evaluate all models on TEMPLAMA (Dhingra et al., 2022) and a new dataset that we call DATESET. TEMPLAMA contains cloze queries about facts that change with time. DATESET, described in Appendix D, is generated through a series of templates, but populated using a combination of random dates/durations (e.g., “What day of the week was it 30 days ago?”). For both tasks, we use the same evaluation as for the original LAMA dataset. Results shown in Table 4 (right) illustrate that Toolformer outperforms all baselines for both TEMPLAMA and DATESET. However, closer inspection shows that improvements on TEMPLAMA can not be attributed to the calendar tool, which is only used for $0 . 2 \\%$ of all examples, but mostly to the Wikipedia search and question answering tools.This makes sense given that entities in TEMPLAMA are often so specific and rare that even knowing the date alone would be of little help. The best course of action for this dataset – first querying the calendar API to get the current date, and then querying the QA system with this date – is not only prohibited by our restriction of using at most one API call, but also hard to learn for Toolformer given that all API calls in its training data are sampled independently. For DATESET, on the other hand, the considerable improvement of Toolformer compared to other models can be fully accredited to the calendar tool, which it makes use of for $5 4 . 8 \\%$ of all examples. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/071c4fdbad1e77e8404f0631b4a51c5e303496f5cf70832da7e556306980604d.jpg",
+        "image_caption": [
+            "Figure 4: Average performance on LAMA, our math benchmarks and our QA benchmarks for GPT-2 models of different sizes and GPT-J finetuned with our approach, both with and without API calls. While API calls are not helpful to the smallest models, larger models learn how to make good use of them. Even for bigger models, the gap between predictions with and without API calls remains high. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            90,
+            808,
+            281
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            376,
+            825,
+            502
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Language Modeling ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            518,
+            352,
+            532
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We want to ensure that language modeling performance of Toolformer does not degrade through finetuning with API calls. To this end, we evaluate our models on two language modeling datasets: WikiText (Merity et al., 2017) and a subset of 10,000 randomly selected documents from CCNet (Wenzek et al., 2020) that were not used during training. Finetuning on CCNet leads to slightly improved performance on the CCNet evaluation subset (perplexity improves from 10.6 to 10.5), but slightly deteriorates performance on WikiText (9.9 to 10.3), presumably because the original pretraining data for GPT-J is more similar to WikiText than our subset of CCNet. Most importantly, however, training on $\\mathcal { C } ^ { * }$ does not lead to an increase in perplexity compared to training on $\\mathcal { C }$ when API calls are disabled at inference time, giving perplexities of 10.5 and 10.3, respectively.5 ",
+        "bbox": [
+            173,
+            544,
+            826,
+            669
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Scaling Laws ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            684,
+            305,
+            699
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We investigate how the ability to ask external tools for help affects performance as we vary the size of our LM. To this end, we apply our approach not just to GPT-J, but also to four smaller models from the GPT-2 family (Radford et al., 2019), with 124M, 355M, 775M and 1.6B parameters, respectively. We do so using only a subset of three tools: the question answering system, the calculator, and the Wikipedia search engine. Apart from this, we follow the experimental setup described in Section 4.1. Figure 4 shows that the ability to leverage the provided tools only emerges at around 775M parameters: smaller models achieve similar performance both with and without tools. An exception to this is the Wikipedia search engine used mostly for QA benchmarks; we hypothesize that this is because the API is comparably easy to use. While models become better at solving tasks without API calls as they grow in size, their ability to make good use of the provided API improves at the same time. Thus, there remains a large gap between predictions with and without API calls even for our biggest model. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            862
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Appendix G, we extend these investigations in scale to the LLaMA v1 7B model (Touvron et al., 2023) to see how tool-use scales with model capability instead of size. We find that the utility of weaker tools such as the WikiSearch tool vanish for these stronger base-models, and we demonstrate the value of generating and scoring with a strong model, compared to simply finetuning. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            170,
+            321,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Language Model Pretraining There are various approaches that augment LMs with some form of additional textual information during pretraining, including various forms of metadata (Keskar et al., 2019), HTML tags (Aghajanyan et al., 2021), Wikipedia markup (Schick et al., 2022), or related texts obtained from an information retrieval system (Guu et al., 2020; Borgeaud et al., 2021; Izacard et al., 2022). For all of these approaches, additional information is always provided, regardless of whether it is helpful or not. In contrast, Toolformer learns for itself to explicitly asks for the right information. ",
+        "bbox": [
+            174,
+            205,
+            826,
+            289
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tool Use Several approaches aim to equip LMs with the ability to use external tools such as search engines (Komeili et al., 2022; Thoppilan et al., 2022; Lazaridou et al., 2022; Shuster et al., 2022; Yao et al., 2022), web browsers (Nakano et al., 2021), calculators (Cobbe et al., 2021; Thoppilan et al., 2022), translation systems (Thoppilan et al., 2022) and Python interpreters (Gao et al., 2022). The way these models learn to use tools can roughly be divided into two approaches: Either they rely on large amounts of human supervision (Komeili et al., 2022; Nakano et al., 2021; Thoppilan et al., 2022) or they work by prompting the language model in a few-shot setup tailored towards a specific task where it is known a priori which tools needs to be used (Gao et al., 2022; Lazaridou et al., 2022; Yao et al., 2022). In contrast, the self-supervised nature of Toolformer enables it to learn how and when to use tools without requiring a specific prompt that shows task-specific examples of how a tool could be used. Perhaps most closely related to our work is TALM (Parisi et al., 2022), an approach that uses a similar self-supervised objective for teaching a model to use a calculator and a search engine, but explores this only in settings where a model is finetuned for downstream tasks. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bootstrapping The idea of using self-training and bootstrapping techniques to improve models has been investigated in various contexts, ranging from word sense disambiguation (Yarowsky, 1995), relation extraction (Brin, 1999; Agichtein and Gravano, 2000), parsing (McClosky et al., 2006), sequence generation (He et al., 2020), few-shot text classification (Schick and Schütze, 2021a) and retrieval (Izacard and Grave, 2021) to reasoning (Zelikman et al., 2022). In a similar spirit, Toolformer is trained on its own predictions after applying a perplexity-based filtering step. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Limitations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            302,
+            631
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While our approach enables LMs to learn how to use a variety of tools in a self-supervised way, there are some clear limitations to what can be achieved with our method in its current form. One such limitation is the inability of Toolformer to use tools in a chain (i.e., using the output of one tool as an input for another tool). This is due to the fact that API calls for each tool are generated independently; as a consequence, there are no examples of chained tool use in the finetuning dataset, since this would necessitate multiple API calls per example. Our current approach also does not allow the LM to use a tool in an interactive way – especially for tools such as search engines, that could potentially return hundreds of different results, enabling a LM to browse through these results or to refine its search query in a similar spirit to Nakano et al. (2021) can be crucial for certain applications. Beyond this, we found models trained with Toolformer to often be sensitive to the exact wording of their input when deciding whether or not to call an API; this is perhaps unsurprising given that LMs are known to be very sensitive to the prompt they are provided with in both zero- and few-shot settings (Jiang et al., 2020; Schick and Schütze, 2021a). Depending on the tool, our method is also very sample-inefficient; for example, processing more than a million documents results in only a few thousand examples of useful calls to the calculator API. A potential solution to this problem might be to iteratively apply our approach, similar to how this is done in related bootstrapping approaches (Schick and Schütze, 2021a; Izacard and Grave, 2021; Parisi et al., 2022). Finally, when deciding whether or not to make an API call, Toolformer currently does not take into account the tool-dependent, computational cost incurred from making an API call. ",
+        "bbox": [
+            174,
+            648,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            299,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have introduced Toolformer, a LM that learns in a self-supervised way how to use different tools such as search engines, calculators, and translation systems via simple API calls. This is done by finetuning on sampled API calls that are filtered based on whether they reduce perplexity on future tokens. Toolformer considerably improves zero-shot performance of a 6.7B parameter GPT-J model, enabling it to even outperform a much larger GPT-3 model on a range of different downstream tasks. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            191
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            213,
+            266,
+            229
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Armen Aghajanyan, Dmytro Okhonko, Mike Lewis, Mandar Joshi, Hu Xu, Gargi Ghosh, and Luke Zettlemoyer. 2021. Htlm: Hyper-text pre-training and prompting of language models. ",
+        "bbox": [
+            176,
+            237,
+            825,
+            266
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eugene Agichtein and Luis Gravano. 2000. Snowball: Extracting relations from large plain-text collections. In Proceedings of the Fifth ACM Conference on Digital Libraries, DL ’00, page 85–94, New York, NY, USA. Association for Computing Machinery. ",
+        "bbox": [
+            176,
+            279,
+            825,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ricardo Baeza-Yates, Berthier Ribeiro-Neto, et al. 1999. Modern information retrieval, volume 463. ACM press New York. ",
+        "bbox": [
+            173,
+            333,
+            823,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Berant, Andrew Chou, Roy Frostig, and Percy Liang. 2013. Semantic parsing on Freebase from question-answer pairs. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pages 1533–1544, Seattle, Washington, USA. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            430
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Millican, George van den Driessche, Jean-Baptiste Lespiau, Bogdan Damoc, Aidan Clark, Diego de Las Casas, Aurelia Guy, Jacob Menick, Roman Ring, Tom Hennigan, Saffron Huang, Loren Maggiore, Chris Jones, Albin Cassirer, Andy Brock, Michela Paganini, Geoffrey Irving, Oriol Vinyals, Simon Osindero, Karen Simonyan, Jack W. Rae, Erich Elsen, and Laurent Sifre. 2021. Improving language models by retrieving from trillions of tokens. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            526
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Brin. 1999. Extracting patterns and relations from the world wide web. In The World Wide Web and Databases, pages 172–183, Berlin, Heidelberg. Springer Berlin Heidelberg. ",
+        "bbox": [
+            173,
+            540,
+            823,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, Sandhini Agarwal, Ariel Herbert-Voss, Gretchen Krueger, Tom Henighan, Rewon Child, Aditya Ramesh, Daniel Ziegler, Jeffrey Wu, Clemens Winter, Chris Hesse, Mark Chen, Eric Sigler, Mateusz Litwin, Scott Gray, Benjamin Chess, Jack Clark, Christopher Berner, Sam McCandlish, Alec Radford, Ilya Sutskever, and Dario Amodei. 2020. Language models are few-shot learners. In Advances in Neural Information Processing Systems, volume 33, pages 1877–1901. Curran Associates, Inc. ",
+        "bbox": [
+            176,
+            580,
+            825,
+            678
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, Parker Schuh, Kensen Shi, Sasha Tsvyashchenko, Joshua Maynez, Abhishek Rao, Parker Barnes, Yi Tay, Noam Shazeer, Vinodkumar Prabhakaran, Emily Reif, Nan Du, Ben Hutchinson, Reiner Pope, James Bradbury, Jacob Austin, Michael Isard, Guy Gur-Ari, Pengcheng Yin, Toju Duke, Anselm Levskaya, Sanjay Ghemawat, Sunipa Dev, Henryk Michalewski, Xavier Garcia, Vedant Misra, Kevin Robinson, Liam Fedus, Denny Zhou, Daphne Ippolito, David Luan, Hyeontaek Lim, Barret Zoph, Alexander Spiridonov, Ryan Sepassi, David Dohan, Shivani Agrawal, Mark Omernick, Andrew M. Dai, Thanumalayan Sankaranarayana Pillai, Marie Pellat, Aitor Lewkowycz, Erica Moreira, Rewon Child, Oleksandr Polozov, Katherine Lee, Zongwei Zhou, Xuezhi Wang, Brennan Saeta, Mark Diaz, Orhan Firat, Michele Catasta, Jason Wei, Kathy Meier-Hellstern, Douglas Eck, Jeff Dean, Slav Petrov, and Noah Fiedel. 2022. Palm: Scaling language modeling with pathways. ",
+        "bbox": [
+            176,
+            690,
+            826,
+            856
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marta R Costa-jussà, James Cross, Onur Çelebi, Maha Elbayad, Kenneth Heafield, Kevin Heffernan, Elahe Kalbassi, Janice Lam, Daniel Licht, Jean Maillard, et al. 2022. No language left behind: Scaling human-centered machine translation. arXiv preprint arXiv:2207.04672. ",
+        "bbox": [
+            178,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, Minneapolis, Minnesota. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            143,
+            825,
+            213
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bhuwan Dhingra, Jeremy R. Cole, Julian Martin Eisenschlos, Daniel Gillick, Jacob Eisenstein, and William W. Cohen. 2022. Time-aware language models as temporal knowledge bases. Transactions of the Association for Computational Linguistics, 10:257–273. ",
+        "bbox": [
+            173,
+            224,
+            826,
+            267
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. 2022. Pal: Program-aided language models. ",
+        "bbox": [
+            171,
+            276,
+            825,
+            306
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Guu, Kenton Lee, Zora Tung, Panupong Pasupat, and Ming-Wei Chang. 2020. Realm: Retrieval-augmented language model pre-training. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            345
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junxian He, Jiatao Gu, Jiajun Shen, and Marc’Aurelio Ranzato. 2020. Revisiting self-training for neural sequence generation. In International Conference on Learning Representations. ",
+        "bbox": [
+            171,
+            354,
+            825,
+            385
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Or Honovich, Thomas Scialom, Omer Levy, and Timo Schick. 2022. Unnatural instructions: Tuning language models with (almost) no human labor. ",
+        "bbox": [
+            174,
+            393,
+            823,
+            422
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gautier Izacard and Edouard Grave. 2021. Distilling knowledge from reader to retriever for question answering. In International Conference on Learning Representations. ",
+        "bbox": [
+            174,
+            433,
+            821,
+            463
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gautier Izacard, Patrick Lewis, Maria Lomeli, Lucas Hosseini, Fabio Petroni, Timo Schick, Jane Dwivedi-Yu, Armand Joulin, Sebastian Riedel, and Edouard Grave. 2022. Atlas: Few-shot learning with retrieval augmented language models. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            515
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Ji, Nayeon Lee, Rita Frieske, Tiezheng Yu, Dan Su, Yan Xu, Etsuko Ishii, Yejin Bang, Andrea Madotto, and Pascale Fung. 2022. Survey of hallucination in natural language generation. ACM Computing Surveys. ",
+        "bbox": [
+            174,
+            525,
+            823,
+            569
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhengbao Jiang, Frank F. Xu, Jun Araki, and Graham Neubig. 2020. How can we know what language models know? Transactions of the Association for Computational Linguistics, 8:423–438. ",
+        "bbox": [
+            171,
+            578,
+            823,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mandar Joshi, Eunsol Choi, Daniel Weld, and Luke Zettlemoyer. 2017. TriviaQA: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 1601–1611, Vancouver, Canada. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            674
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin, Edouard Grave, Piotr Bojanowski, Matthijs Douze, Hérve Jégou, and Tomas Mikolov. 2016. Fasttext. zip: Compressing text classification models. arXiv preprint arXiv:1612.03651. ",
+        "bbox": [
+            173,
+            684,
+            821,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Bryan McCann, Lav R. Varshney, Caiming Xiong, and Richard Socher. 2019. Ctrl: A conditional transformer language model for controllable generation. ",
+        "bbox": [
+            173,
+            723,
+            823,
+            753
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Philipp Koehn. 2005. Europarl: A parallel corpus for statistical machine translation. In Proceedings of machine translation summit x: papers, pages 79–86. ",
+        "bbox": [
+            171,
+            762,
+            825,
+            792
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mojtaba Komeili, Kurt Shuster, and Jason Weston. 2022. Internet-augmented dialogue generation. In Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pages 8460–8478, Dublin, Ireland. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            801,
+            823,
+            844
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rik Koncel-Kedziorski, Subhro Roy, Aida Amini, Nate Kushman, and Hannaneh Hajishirzi. 2016. MAWPS: A math word problem repository. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 1152–1157, San Diego, California. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            854,
+            826,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Jacob Devlin, Kenton Lee, Kristina Toutanova, Llion Jones, Matthew Kelcey, Ming-Wei Chang, Andrew M. Dai, Jakob Uszkoreit, Quoc Le, and Slav Petrov. 2019. Natural questions: A benchmark for question answering research. Transactions of the Association for Computational Linguistics, 7:452–466. ",
+        "bbox": [
+            176,
+            90,
+            826,
+            161
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Angeliki Lazaridou, Elena Gribovskaya, Wojciech Stokowiec, and Nikolai Grigorev. 2022. Internetaugmented language models through few-shot prompting for open-domain question answering. arXiv preprint arXiv:2203.05115. ",
+        "bbox": [
+            174,
+            170,
+            826,
+            212
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Patrick Lewis, Barlas Oguz, Ruty Rinott, Sebastian Riedel, and Holger Schwenk. 2019. Mlqa:˘ Evaluating cross-lingual extractive question answering. arXiv preprint arXiv:1910.07475. ",
+        "bbox": [
+            173,
+            222,
+            821,
+            251
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xi Victoria Lin, Todor Mihaylov, Mikel Artetxe, Tianlu Wang, Shuohui Chen, Daniel Simig, Myle Ott, Naman Goyal, Shruti Bhosale, Jingfei Du, Ramakanth Pasunuru, Sam Shleifer, Punit Singh Koura, Vishrav Chaudhary, Brian O’Horo, Jeff Wang, Luke Zettlemoyer, Zornitsa Kozareva, Mona Diab, Veselin Stoyanov, and Xian Li. 2021. Few-shot learning with multilingual language models. ",
+        "bbox": [
+            174,
+            258,
+            826,
+            315
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Joshua Maynez, Shashi Narayan, Bernd Bohnet, and Ryan McDonald. 2020. On faithfulness and factuality in abstractive summarization. ",
+        "bbox": [
+            173,
+            325,
+            823,
+            353
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David McClosky, Eugene Charniak, and Mark Johnson. 2006. Effective self-training for parsing. In Proceedings of the Human Language Technology Conference of the NAACL, Main Conference, pages 152–159, New York City, USA. Association for Computational Linguistics. ",
+        "bbox": [
+            173,
+            362,
+            825,
+            405
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. 2017. Pointer sentinel mixture models. In International Conference on Learning Representations. ",
+        "bbox": [
+            171,
+            414,
+            823,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shen-yun Miao, Chao-Chun Liang, and Keh-Yih Su. 2020. A diverse corpus for evaluating and developing English math word problem solvers. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 975–984, Online. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            508
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Reiichiro Nakano, Jacob Hilton, Suchir Balaji, Jeff Wu, Long Ouyang, Christina Kim, Christopher Hesse, Shantanu Jain, Vineet Kosaraju, William Saunders, Xu Jiang, Karl Cobbe, Tyna Eloundou, Gretchen Krueger, Kevin Button, Matthew Knight, Benjamin Chess, and John Schulman. 2021. Webgpt: Browser-assisted question-answering with human feedback. ",
+        "bbox": [
+            174,
+            517,
+            826,
+            574
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron Parisi, Yao Zhao, and Noah Fiedel. 2022. Talm: Tool augmented language models. ",
+        "bbox": [
+            171,
+            583,
+            759,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Arkil Patel, Satwik Bhattamishra, and Navin Goyal. 2021. Are NLP models really able to solve simple math word problems? In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 2080–2094, Online. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            664
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Fabio Petroni, Aleksandra Piktus, Angela Fan, Patrick Lewis, Majid Yazdani, Nicola De Cao, James Thorne, Yacine Jernite, Vladimir Karpukhin, Jean Maillard, Vassilis Plachouras, Tim Rocktäschel, and Sebastian Riedel. 2021. KILT: a benchmark for knowledge intensive language tasks. In Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 2523–2544, Online. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            756
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Fabio Petroni, Tim Rocktäschel, Sebastian Riedel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, and Alexander Miller. 2019. Language models as knowledge bases? In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pages 2463–2473, Hong Kong, China. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            835
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, Ilya Sutskever, et al. 2019. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            873
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Stephen E Robertson, Steve Walker, Susan Jones, Micheline M Hancock-Beaulieu, Mike Gatford, et al. 1995. Okapi at trec-3. Nist Special Publication Sp, 109:109. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Timo Schick, Jane Dwivedi-Yu, Zhengbao Jiang, Fabio Petroni, Patrick Lewis, Gautier Izacard, Qingfei You, Christoforos Nalmpantis, Edouard Grave, and Sebastian Riedel. 2022. Peer: A collaborative language model. ",
+        "bbox": [
+            176,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Timo Schick and Hinrich Schütze. 2021a. Exploiting cloze-questions for few-shot text classification and natural language inference. In Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, pages 255–269, Online. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            142,
+            826,
+            198
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Timo Schick and Hinrich Schütze. 2021b. Generating datasets with pretrained language models. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, pages 6943–6951, Online and Punta Cana, Dominican Republic. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            263
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kurt Shuster, Jing Xu, Mojtaba Komeili, Da Ju, Eric Michael Smith, Stephen Roller, Megan Ung, Moya Chen, Kushal Arora, Joshua Lane, Morteza Behrooz, William Ngan, Spencer Poff, Naman Goyal, Arthur Szlam, Y-Lan Boureau, Melanie Kambadur, and Jason Weston. 2022. Blenderbot 3: a deployed conversational agent that continually learns to responsibly engage. ",
+        "bbox": [
+            174,
+            272,
+            826,
+            329
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Romal Thoppilan, Daniel De Freitas, Jamie Hall, Noam Shazeer, Apoorv Kulshreshtha, Heng-Tze Cheng, Alicia Jin, Taylor Bos, Leslie Baker, Yu Du, YaGuang Li, Hongrae Lee, Huaixiu Steven Zheng, Amin Ghafouri, Marcelo Menegali, Yanping Huang, Maxim Krikun, Dmitry Lepikhin, James Qin, Dehao Chen, Yuanzhong Xu, Zhifeng Chen, Adam Roberts, Maarten Bosma, Vincent Zhao, Yanqi Zhou, Chung-Ching Chang, Igor Krivokon, Will Rusch, Marc Pickett, Pranesh Srinivasan, Laichee Man, Kathleen Meier-Hellstern, Meredith Ringel Morris, Tulsee Doshi, Renelito Delos Santos, Toju Duke, Johnny Soraker, Ben Zevenbergen, Vinodkumar Prabhakaran, Mark Diaz, Ben Hutchinson, Kristen Olson, Alejandra Molina, Erin Hoffman-John, Josh Lee, Lora Aroyo, Ravi Rajakumar, Alena Butryna, Matthew Lamm, Viktoriya Kuzmina, Joe Fenton, Aaron Cohen, Rachel Bernstein, Ray Kurzweil, Blaise Aguera-Arcas, Claire Cui, Marian Croak, Ed Chi, and Quoc Le. 2022. Lamda: Language models for dialog applications. ",
+        "bbox": [
+            174,
+            338,
+            826,
+            489
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothée Lacroix, Baptiste Rozière, Naman Goyal, Eric Hambro, Faisal Azhar, Aurelien Rodriguez, Armand Joulin, Edouard Grave, and Guillaume Lample. 2023. Llama: Open and efficient foundation language models. ",
+        "bbox": [
+            173,
+            500,
+            825,
+            555
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ben Wang and Aran Komatsuzaki. 2021. GPT-J-6B: A 6 Billion Parameter Autoregressive Language Model. https://github.com/kingoflolz/mesh-transformer-jax. ",
+        "bbox": [
+            171,
+            564,
+            821,
+            593
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A. Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2022. Self-instruct: Aligning language model with self generated instructions. ",
+        "bbox": [
+            176,
+            602,
+            823,
+            645
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Guillaume Wenzek, Marie-Anne Lachaux, Alexis Conneau, Vishrav Chaudhary, Francisco Guzmán, Armand Joulin, and Edouard Grave. 2020. CCNet: Extracting high quality monolingual datasets from web crawl data. In Proceedings of the Twelfth Language Resources and Evaluation Conference, pages 4003–4012, Marseille, France. European Language Resources Association. ",
+        "bbox": [
+            174,
+            654,
+            826,
+            709
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models. ",
+        "bbox": [
+            171,
+            718,
+            825,
+            747
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Yarowsky. 1995. Unsupervised word sense disambiguation rivaling supervised methods. In 33rd Annual Meeting of the Association for Computational Linguistics, pages 189–196, Cambridge, Massachusetts, USA. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            756,
+            826,
+            799
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Zelikman, Yuhuai Wu, Jesse Mu, and Noah D. Goodman. 2022. Star: Bootstrapping reasoning with reasoning. ",
+        "bbox": [
+            174,
+            808,
+            821,
+            837
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen, Christopher Dewan, Mona Diab, Xian Li, Xi Victoria Lin, Todor Mihaylov, Myle Ott, Sam Shleifer, Kurt Shuster, Daniel Simig, Punit Singh Koura, Anjali Sridhar, Tianlu Wang, and Luke Zettlemoyer. 2022. Opt: Open pre-trained transformer language models. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            901
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/aUkOeKsGe2X/aUkOeKsGe2X.md

@@ -0,0 +1,345 @@
+# AUTOENCODER FOR SYNTHETIC TO REAL GENERAL-IZATION: FROM SIMPLE TO MORE COMPLEX SCENES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Learning on synthetic data and transferring the resulting properties to their real counterparts is an important challenge for reducing costs and increasing safety in machine learning. In this work, we focus on autoencoder architectures and aim at learning latent space representations that are invariant to inductive biases caused by the domain shift between simulated and real images showing the same scenario. We train on synthetic images only, present approaches to increase generalizability and improve the preservation of the semantics to real datasets of increasing visual complexity. We show that pre-trained feature extractors (e.g. VGG) can be sufficient for generalization on images of lower complexity, but additional improvements are required for visually more complex scenes. To this end, we demonstrate a new sampling technique, which matches semantically important parts of the image, while randomizing the other parts, leads to salient feature extraction and a neglection of unimportant parts. This helps the generalization to real data and we further show that our approach outperforms fine-tuned classification models.
+
+# 1 INTRODUCTION
+
+The generation of synthetic data constitutes a cost efficient way for acquiring machine learning training data together with exact and free annotations. Notwithstanding this obvious advantage, bridging the gap between synthetic and real data remains an open challenge, in particular for camera based applications. Learning from synthetic data is an important tool in robotics: Lee et al. (2020) introduced a method for training a quadrupedal robot on synthetic data by incorporating proprioceptive feedback. Akkaya et al. (2019) trained a robot hand to solve real Rubik’s cubes by learning the model in a simulation only. Zhang et al. (2019) made the robot feel at home by translating the real world input data into synthetic data for their reinforcement learning agent. In view of safety critical applications, synthetic data can provide the means to reduce costs related to acquiring samples for edge cases, or which are difficult to obtain because they are too dangerous, e.g. accidents. We focus on learning invariances empirically on synthetic data, which should transfer to real data, as opposed to constructing invariances as in equivariant neural networks (Romero & Hoogendoorn, 2020).
+
+We investigate the case of single independent images for which consistency between frames and physical interactions cannot be taken advantage of. The latter is commonly used by reinforcement learning methods (Lee et al., 2020). We focus on training on synthetic data only and limit ourselves to autoencoder models which provide interesting properties due to their bottleneck design. The low-dimensional latent space of autoencoders can be subject to metric constraints (Hoffer & Ailon, 2015), allows for scene decomposition (Engelcke et al., 2020) and it is believed that latent factor disentanglement can be useful for downstream tasks (van Steenkiste et al., 2019). We assess to what extend we can generalize to real images and we highlight which design choices improve the autoencoder models performance with respect to accuracy and reconstruction quality. To this end, we first develop a method using features of pre-trained classifiers and show that we achieve better results on MPI3D (Gondal et al., 2019) to generalize from synthetic (toy or realistic) to real images compared to Autoencoder, Variational Autoencoder (VAE) (Kingma & Welling, 2014), $\beta$ - VAE (Higgins et al., 2017) and FactorVAE (Kim & Mnih, 2018). Although successful, we highlight that insights and design choices on a simple dataset do not necessarily transfer to real applications of higher visual complexity. To improve generalization, we propose to use the partially impossible reconstruction loss (PIRL) (Dias Da Cruz et al., 2021) (matching semantically important parts while randomizing the other parts) and we propose a novel variation thereof. We extensively show that our variation is the driving force for the improved generalization capacities. Additionally, we induce structure in the latent space by a triplet loss regularization. We evaluate and justify the benefits of the different design choices on an automotive application focusing on occupancy classification in the vehicle interior. The challenge of training in a single vehicle interior and transferring results between different vehicle interiors has been investigated by Dias Da Cruz et al. (2021). The latter and similar industrial applications suffer from the limited availability and variability of training data. A successful transfer from synthetic to real data would avoid the necessity of collecting real data for each vehicle interior: the invariances could be learned and improved on synthetic data only.
+
+![](images/40c198ac0999a1f43500c6b8d0cbde127e17c08caa224e39542524b626016d6a.jpg)  
+Figure 1: Impossible Instance Extractor Triplet Autoencoder (II-E-TAE) model architecture.
+
+# 2 RELATED WORKS
+
+There have been successful applications of reinforcement learning systems being trained in a simulated environment and deployed to a real one, for example by combining real and synthetic data during training (Kang et al., 2019; Rao et al., 2020; Fang et al., 2018; Bewley et al., 2019). However, these approaches can take into account temporal information and action-reaction causalities while in this work we use independent frames only. A good overview on reinforcement learning based simulation to real transferability is provided in (Zhao et al., 2020). Another line of research uses generative adversarial networks (GAN) to make synthetic images look like real images or vice versa (Ho et al., 2020; Carlson et al., 2019). This requires both synthetic and real images, whereas we focus on training on synthetic images only. Part of our methodology is related to domain randomization (Tremblay et al., 2018), where the environment is being randomized, but Tremblay et al. (2018) deployed this to object detection and the resulting model needs to be fine-tuned on real data. A similar idea of freezing the layers of a pre-trained model was investigated for object detection (Hinterstoisser et al., 2018), but neither with a dedicated sampling strategy nor in the context of autoencoders. While Tobin et al. (2017) focuses on localization and training on synthetic images only, the applicability is only tested on simple geometries. Although, we start our investigations on the simple dataset MPI3D, we increase the visual complexity by incorporating human models and child seats. Inoue et al. (2018) and Zhang et al. (2015) rely on the use of real images during training as well for the minimization of the synthetic to real gap for autoencoders. Recent advances on synthetic to real image segmentation (Chen et al., 2020; Yue et al., 2019; Pan et al., 2018) on the VisDA (Peng et al., 2017) dataset show a promising direction to overcome the gap between synthetic and real images, however, this cannot straightforwardly be compared against the investigation in this work, particularly, since we are focusing on autoencoder models and their generative nature. While our cost function variation is based on Dias Da Cruz et al. (2021), we show that our approach improves generalization while needing less demanding training data such that it can easily be applied to any commonly recorded dataset (i.e. no variations of the same scene are needed).
+
+# 3 METHOD
+
+Consider $N _ { s }$ sceneries and $N _ { v }$ variations of the same scenery, e.g. same scenery under different illuminations, with different backgrounds or under different data augmentation transformations. Let $\mathcal { X } = \{ X _ { i } ^ { j } | 1 \le i \le N _ { v } , 1 \le j \le N _ { s } \}$ denote the training data, where each $X _ { i } ^ { j } ~ \in ~ \mathbb { R } ^ { C \times H \times W }$ is the ith variation of scene $j$ consisting of $C$ channels and being of height $H$ and width $W$ . Let $X ^ { j } = \{ X _ { i } ^ { j } | 1 \leq i \leq N _ { v } \}$ be the set of all variations $i$ of scenery $j$ and $\mathcal { V } = \{ Y ^ { j } | 1 \le j \le N _ { s } \}$ be the corresponding target classes of the scenes of $\mathcal { X }$ . Notice that the classes remain constant for the variations $i$ of each scene $j$ . In the following, we will present the final model architecture as illustrated in Fig. 1 and we provide evidences for each design choice in Section 4.
+
+![](images/f525930f7109f4a5a7374812d496b8eb857a5292a06c680efe38c5ea117e6e5f.jpg)  
+Figure 2: Illustration of the different input-target pairs for the autoencoder reconstruction loss.
+
+# 3.1 MODEL ARCHITECTURE: EXTRACTOR AUTOENCODER
+
+By an abuse of terminology, we will refer to our method as a variation of vanilla autoencoders, although an encoder-decoder formulation would strictly speaking be more correct, because the goal will not be to reconstruct the input image exactly. We propose to apply ideas from transfer learning and use a pre-trained classification model to extract more general features from the input images. Instead of using the images itself, the extracted features are used as input. Our autoencoder consists of a summarization module which reduces the number of convolutional filters. This is fed to a simple MLP encoder which is then decoded by a transposed convolutional network. We refer to this model as extractor autoencoder (E-AE). Let $\mathrm { e } _ { \phi }$ be the encoder, $\mathrm { d } _ { \theta }$ the decoder and $\mathrm { e x t } _ { \omega }$ be a pre-trained classification model, referred to as extractor. For ease of notation, we define $\mathrm { e } _ { \phi } ( \mathrm { e x t } _ { \omega } ( \cdot ) ) = \mathrm { e e } _ { \phi , \omega } ( \cdot )$ . The model, using the vanilla reconstruction loss, can be formulated for a single input sample as
+
+$$
+\begin{array} { r } { \mathcal { L } _ { R } ( X _ { i } ^ { j } ; \theta , \phi ) = \mathrm { r } \left( \mathrm { d } _ { \theta } ( \mathrm { e x t } _ { \omega } ( X _ { i } ^ { j } ) ) ) , X _ { i } ^ { j } \right) = \mathrm { r } \left( \mathrm { d } _ { \theta } ( \mathrm { e e } _ { \phi , \omega } ( X _ { i } ^ { j } ) ) , X _ { i } ^ { j } \right) , } \end{array}
+$$
+
+where $\mathrm { r } ( \cdot , \cdot )$ computes the error loss between target and reconstruction. We use the structural similarity index measure (SSIM) (Bergmann et al., 2018) and binary cross entropy (BCE), but our method is not limited to them. Model details are provided in the appendix A.2.1.
+
+# 3.2 SAMPLING STRATEGY: PARTIAL IMPOSSIBLE
+
+An additional improvement to the autoencoder training approach is a dedicated sampling strategy for which we provide two variations. The first one is the partially impossible reconstruction loss (PIRL) as introduced by Dias Da Cruz et al. (2021) for illumination normalization. As our results will show, this also helps the transfer between synthetic and real images. For sampling the individual elements of a batch, we randomly select for each scene two images, one as input and the other one as target. This sampling strategy preserves the semantics while varying the unimportant features such that the model needs to focus on what remains constant. For random $a , b \in [ 0 , \mathsf { \bar { N } } _ { v } ]$ and $a \neq b$ :
+
+$$
+\begin{array} { r } { \mathcal { L } _ { R , I } ( X _ { a } ^ { j } ; \theta , \phi ) = \mathrm { r } \left( \mathrm { d } _ { \theta } \big ( \mathrm { e e } _ { \phi , \omega } ( X _ { a } ^ { j } ) \big ) , X _ { b } ^ { j } \right) . } \end{array}
+$$
+
+We refer to models using the PIRL by prepending an $I$ , e.g. I-E-AE.
+
+# 3.3 SAMPLING STRATEGY: PARTIAL IMPOSSIBLE CLASS INSTANCE
+
+We propose a novel variation to further improve this strategy by sampling a target image of a different scene, but of the same class. This should cause the model to learn invariances with respect to certain class variations which are not important for the task at hand, e.g. clothes, human poses, textures. This sampling variation would be reflected in the reconstruction loss as follows
+
+$$
+\begin{array} { r } { \mathcal { L } _ { R , I I } ( X _ { a } ^ { j } ; \theta , \phi ) = \mathrm { r } \left( \mathrm { d } _ { \theta } ( \mathrm e \varphi _ { \phi , \omega } ( X _ { a } ^ { j } ) ) , X _ { b } ^ { k } \right) , } \end{array}
+$$
+
+for random $a , b \in [ 0 , N _ { v } ]$ , $j \neq k$ and $Y ^ { j } = Y ^ { k }$ . We refer to this method as impossible class instance sampling marked by prepending $\boldsymbol { { I I } }$ , e.g. II-E-AE. It is important to notice that our novel variation can easily be applied to any common dataset. The sampling variations are visualized in Fig. 2.
+
+# 3.4 STRUCTURE IN THE LATENT SPACE: TRIPLET LOSS
+
+The final adjustment to our training strategy is the incorporation of the triplet loss regularization in the latent space (Hoffer & Ailon, 2015) to induce structure. This can be integrated by
+
+$$
+\mathcal { L } _ { T } ( X _ { a } ^ { j } ; \phi ) = \operatorname* { m a x } \left( 0 , \left. \mathrm { e e } _ { \phi , \omega } ( X _ { a } ^ { j } ) - \mathrm { e e } _ { \phi , \omega } ( X _ { b } ^ { k } ) \right. ^ { 2 } - \left. \mathrm { e e } _ { \phi , \omega } ( X _ { a } ^ { j } ) - \mathrm { e e } _ { \phi , \omega } ( X _ { c } ^ { l } ) \right. ^ { 2 } + 0 . 2 \right) ,
+$$
+
+for random $a , b , c \in [ 0 , N _ { v } ]$ , $j \neq k \neq l$ and $Y ^ { j } = Y ^ { k } \neq Y ^ { l }$ . We refer to this model as triplet autoencoder (TAE) either with or without using the PIRL. We can sample impossible target instances for the positive and negative triplet samples such that the total loss becomes (for some $\alpha$ and $\beta$ ):
+
+$$
+\begin{array} { r } { \mathcal { L } ( X _ { a } ^ { j } ; \theta , \phi ) = \alpha \mathcal { L } _ { T } ( X _ { a } ^ { j } ; \phi ) + \beta \left( \mathcal { L } _ { R , I I } ( X _ { a } ^ { j } ; \theta , \phi ) + \mathcal { L } _ { R , I I } ( X _ { b } ^ { k } ; \theta , \phi ) + \mathcal { L } _ { R , I I } ( X _ { c } ^ { l } ; \theta , \phi ) \right) . } \end{array}
+$$
+
+# 4 EXPERIMENTS
+
+This section is organized in observations, formulated as subsections, which are built on one another and contain results highlighting the improvements. This provides explanations for the design choices leading to our final model architecture and cost function formulations presented in Section 3. Improvements regarding the transfer to real images when only being trained on synthetic images are assessed qualitatively based on reconstruction quality and latent space structure and quantitatively on classification accuracy. All experiments use the same hyperparameters whenever possible. Training details and additional results are provided in the appendix and in our implementation.
+
+We perform a baseline evaluation on MPI3D (Gondal et al., 2019), which provides simple and realistic renderings and real counterparts. We reduced the dataset to contain only the large objects. For a higher visual complexity, we use as synthetic images the SVIRO (Dias Da Cruz et al., 2020) dataset. TICaM (Katrolia et al., 2021) is used to evaluate the performance on a real dataset of a similar application. The latter datasets are grayscale images from the vehicle interior and consider the task of classification (empty, infant, child or adult) for each seat position. The design choices made on MPI3D and the available synthetic images are not sufficient to obtain a good transferability to real images from the vehicle interior. Hence, we release an additional dataset, see Section 4.5 and A.1.4. We introduce step by step modifications to the autoencoder architecture leading to steady quantitative and qualitative improvements. MPI3D and the vehicle interior share interesting properties: they have almost identical backgrounds and the environment is more tractable than many computer vision datasets. The transfer from SVIRO to TICaM is further complicated by new unseen attributes, e.g. steering wheel. An additional ablation study shows that our novel variation of PIRL is the driving force for the improved generalization capacity. Finally, to be in line with common benchmark datasets, we show that our design choices also improve the transfer from training on MNIST (LeCun et al., 1998) to generalizing to real images of digits (De Campos et al., 2009).
+
+# 4.1 AUTOENCODERS STRUGGLE ON REAL IMAGES WHEN TRAINED ON SYNTHETIC IMAGES
+
+In the first, albeit na¨ıve experiment we assumed that due to the bottleneck of autoencoders, the latter should generalize to some extent to real images when trained on synthetic ones. We trained convolutional autoencoders (AE) on the toy and realistic MPI3D images, respectively, and evaluated the resulting models on the real recordings. The first row of Fig. 3b shows the reconstruction of real images when trained on the realistic synthetic images: the model preserves some of the semantics. The model fails to perform senseful reconstructions when trained on toy images, see Fig. 3c.
+
+# 4.2 AUTOENCODERS OVERFIT TO THE SYNTHETIC DISTRIBUTION
+
+An immediate consequence of the results of the previous section is the assumption that the autoencoder overfits to the synthetic distribution and takes into consideration some artefacts (e.g. rendering noise). We followed the idea of Gondal et al. (2019) and trained Variational Autoencoder (VAE) (Kingma & Welling, 2014), $\beta$ -VAE (Higgins et al., 2017) and FactorVAE (Kim & Mnih, 2018) on the same data as before using the BCE reconstruction loss. The results in the second $\beta$ -VAE with $\beta = 8$ ) and third (FactorVAE with $\gamma = 5 0$ ) row of Fig. 3b show that the models reconstruct real images better and more of the semantics are preserved. If trained on toy renderings, the representation gap is too large, causing the reconstruction of the real images to be bad: see Fig. 3c.
+
+# 4.3 MORE GENERAL INPUT FEATURES IMPROVE AUTOENCODER RECONSTRUCTIONS
+
+A small gap between the synthetic and real distribution can potentially be closed by a dedicated data augmentation approach to avoid overfitting to synthetic artefacts. Nevertheless, and while making sense, an abstraction from toy to real images cannot be achieved by means of simple data transformations or model constraints (e.g. denoising autoencoder). To this end we propose to use a (a) Synthetic realistic and toy training data as well as real data used as input after training (b) Reconstruction of real data when being trained on realistic data.
+
+![](images/db606ab564fb554bdc68096e90d37d57c729a2703f583ee9a2724ce27a15c9dd.jpg)
+
+![](images/b5c4273e246fb0d9bfe97bc6f85d6aa8e9268600bd6dc1f5d8f6bbf75c352d4d.jpg)
+
+![](images/74146757d8795cea08c1f93a2bbf952eea2c98a1572f0d43b12d006b0d909e8d.jpg)  
+(c) Reconstruction of real data when being trained on toy data.
+
+![](images/23c7452661ed37019e8f46d5d7f3b01bbbf06cb1b2d71dedb3b96b4800d72027.jpg)  
+Figure 3: Reconstruction of unseen real data for different autoencoders: Autoencoder (AE), $\beta$ Variational Autoencoder $\beta$ -VAE), FactorVAE (F-VAE) and Extractor Autoencoder (E-AE).   
+Figure 4: t-SNE projection of the 10 dimensional latent space representation of the realistic training (blue circle) together with the real (orange cross) images. Autoencoder (AE), $\beta$ Variational Autoencoder ( $\beta$ -VAE), FactorVAE and Extractor Autoencoder (E-AE). The extractor approach is the only method clustering both synthetic and real images together.
+
+pre-trained feature extractor as presented in Section 3 and as defined by Eq. 1. In the following, we used the VGG-11 model pre-trained on Imagenet as the extractor if not stated otherwise.
+
+The results from the fourth row of Fig. 3b and Fig. 3c, respectively, show that the proposed modifications enable the model to generalize to real images when trained on synthetic ones. Much more of the semantics are preserved even when the model was only trained on toy images. Our method produces semantically more correct and less noisy reconstructions compared to the VAE and FactorVAE baseline results. Additional qualitative improvements are highlighted by visualizing the latent space: both the 10-dimensional training (synthetic) and test (real) data latent spaces are projected together into a 2-dimensional representation using t-SNE. In Fig. 4 we can observe that VAE and FactorVAE improve the representation of real and synthetic images in the same region in the latent space, however, only partially, indicating a different representation for real and synthetic images. When using E-AE, real and synthetic images are represented more similarly in the latent space and the clusters are completely overlapping. Even when trained on the toy dataset, the latent space representation for synthetic and real images produced by E-AE overlaps partially as visualized in the appendix Fig. 8. Finally, we report in Table 1 a quantitative evaluation between the reconstructions of the real images against their synthetic training counterparts across all dataset images for different norms. We compute the same metrics between the real input images and their reconstruction to measure whether the semantics are being preserved : in all cases E-AE performs best. Additional results can be found in the appendix in Table 8 and reconstructions of synthetic input images in Fig 9. The latter shows that all models perform similarly well on the training data, hence the training was successful, but our proposed design choices generalize best to the real images.
+
+Table 1: We report the L1, SSIM and LIPIPS (Zhang et al., 2018) norm between the reconstructions of the real images (unknown) and the corresponding synthetic (Synth.) training images (realistic or toy) or input images (Real). We report the mean of the norms across the dataset: for SSIM larger $\uparrow$ and for the others smaller $\downarrow$ is better. E-AE performs best.   
+
+<table><tr><td></td><td></td><td></td><td colspan="2">L1↓</td><td colspan="2">SSIM↑</td><td colspan="2">LPIPS↓</td></tr><tr><td>Trained on</td><td>Model</td><td>Variant</td><td>Synth.</td><td>Real</td><td>Synth.</td><td>Real</td><td>Synth.</td><td>Real</td></tr><tr><td>Toy</td><td>AE</td><td>SSIM</td><td>932</td><td>1763</td><td>0.56</td><td>0.42</td><td>0.35</td><td>0.40</td></tr><tr><td>Toy</td><td>VAE</td><td>BCE</td><td>659</td><td>1497</td><td>0.50</td><td>0.33</td><td>0.34</td><td>0.42</td></tr><tr><td>Toy</td><td>β-VAE</td><td>BCE,β=4</td><td>710</td><td>1542</td><td>0.53</td><td>0.38</td><td>0.31</td><td>0.44</td></tr><tr><td>Toy</td><td>β-VAE</td><td>BCE,β=8</td><td>406</td><td>1321</td><td>0.71</td><td>0.48</td><td>0.26</td><td>0.37</td></tr><tr><td>Toy</td><td>FactorVAE</td><td>BCE,= 10</td><td>521</td><td>1288</td><td>0.66</td><td>0.45</td><td>0.26</td><td>0.39</td></tr><tr><td>Toy</td><td>FactorVAE</td><td>BCE, = 50</td><td>430</td><td>1295</td><td>0.71</td><td>0.51</td><td>0.22</td><td>0.35</td></tr><tr><td>Toy</td><td>E-AE (ours)</td><td>SSIM</td><td>177</td><td>1165</td><td>0.90</td><td>0.58</td><td>0.10</td><td>0.28</td></tr><tr><td>Realistic</td><td>AE</td><td>SSIM</td><td>568</td><td>1133</td><td>0.83</td><td>0.62</td><td>0.20</td><td>0.24</td></tr><tr><td>Realistic</td><td>VAE</td><td>BCE</td><td>482</td><td>890</td><td>0.74</td><td>0.61</td><td>0.20</td><td>0.23</td></tr><tr><td>Realistic</td><td>β-VAE</td><td>BCE,β= 4</td><td>372</td><td>833</td><td>0.81</td><td>0.64</td><td>0.18</td><td>0.20</td></tr><tr><td>Realistic</td><td>β-VAE</td><td>BCE,β=8</td><td>384</td><td>854</td><td>0.79</td><td>0.64</td><td>0.19</td><td>0.21</td></tr><tr><td>Realistic</td><td>FactorVAE</td><td>BCE, = 10</td><td>218</td><td>734</td><td>0.88</td><td>0.68</td><td>0.15</td><td>0.19</td></tr><tr><td>Realistic</td><td>FactorVAE</td><td>BCE,= 50</td><td>391</td><td>830</td><td>0.78</td><td>0.64</td><td>0.16</td><td>0.18</td></tr><tr><td>Realistic</td><td>E-AE (ours)</td><td>SSIM</td><td>251</td><td>841</td><td>0.92</td><td>0.70</td><td>0.08</td><td>0.14</td></tr></table>
+
+# 4.4 IT WORKS FOR VISUALLY SIMPLE IMAGES - MORE IS NEEDED ON MORE COMPLEX DATA
+
+Since the method introduced in the previous section achieved good results, even when being trained on toy images, we were optimistic to apply it to images of higher visual complexity, e.g. a vehicle interior. We trained the same model architecture as in the previous section, but with a 64-dimensional latent space, on images from the Tesla vehicle from SVIRO and the Kodiaq vehicle from SVIROIllumination dataset, respectively, and evaluated the model on the real TICaM images. Examples of the resulting model’s reconstructions are plotted in Fig. 5 (b) and in the appendix Fig. 10. In both cases only blurry human models are being reconstructed, which is similar to the mode collapse in the first row of Fig. 3c. We concluded that more robust features are needed.
+
+# 4.5 PARTIALLY IMPOSSIBLE RECONSTRUCTION LOSS HELPS GENERALIZATION
+
+As defined by Eq. 2, a partially impossible reconstruction loss (PIRL) for autoencoders has proven to work well for image normalization (Dias Da Cruz et al., 2021). We hypothesized that the same approach could lead to a better generalization to real vehicle interiors. In a first approach, we applied this strategy to variations of the same scene under different illumination conditions, but realized that the learned invariances are not suitable for the transfer between synthetic and real. An example is provided in Fig. 5 (c) where we trained on the Kodiaq images from the SVIRO-Illumination dataset.
+
+![](images/4281065016928bbab651c5b624d62a1d31e928c2bf2d37618ea3d1b593ca8a77.jpg)  
+Figure 5: Reconstructions of unseen real data (a) from TICaM: (b) E-AE and (c) I-E-AE trained on Kodiaq SVIRO-Illumination, (d) E-AE, (e) I-E-AE, (f) II-E-AE and (g) II-E-TAE trained on our new dataset. A red (wrong) or green (correct) box highlights whether the classes are preserved.
+
+We concluded that, for learning more general features by applying the PIRL, we needed input-target pairs where both images are of the same scene, but differ in the properties we want to become invariant to: the dominant background. To this end we created 5919 synthetic scenes where we placed humans, child and infant seats as if they would be sitting in a vehicle interior, but instead of a vehicle, the background was replaced by selecting randomly from a pool of available HDRI images. Each scene was rendered using 10 different backgrounds. Examples from the dataset are shown in Fig. 7 in the appendix. During training, we randomly select two images per scene and use one as input and the other as target, i.e. as defined in Eq. 2. When applied to real images, see Fig. 5 (e), the model better preserves the semantics of the real images: the model starts to reconstruct child seats and not people only, anymore. We also trained a model without the PIRL to show that the success is not due to the design choice of the dataset: in Fig. 5 (d) the model performs worse.
+
+Finally, we extended this idea further with our novel PIRL loss formulation: instead of taking the same scene with a different background as target image, we randomly selected a different scene of the same class, e.g. if a person is sitting at the left seat position, we would take another image with a person on the left seat, potentially a different person with a different pose. This approach is formulated in Eq. 3. While this leads to a blurrier object reconstruction, which is expected because the autoencoder needs to learn an average class representation, the classes are preserved more robustly and the reconstructions look better than before, see Fig. 5 (f). Moreover, this additional randomization improves classification accuracy as discussed in Section 4.7 and in Section 5. A visualization of the different input-target pair combinations can be found in Fig. 2. The dataset can been downloaded from this link (Google Drive - Anonymous user) and it will be made publicly available.
+
+# 4.6 STRUCTURE IN THE LATENT SPACE HELPS GENERALIZATION
+
+The final improvement is based on the assumption that structure in the latent space should help the model performance. Class labels are included by formulating a triplet loss regularization to the latent space representation as defined by Eq. 4: images of the same class should be mapped closely together and images of different classes pushed away. The triplet loss induces a more meaningful $L ^ { \tilde { 2 } }$ -norm in the latent space (Dias Da Cruz et al., 2021) such that a k-nearest neighbor (KNN) classifier can be used in the next section. As the results of Fig. 5 (g) and in the appendix show, these final improvements, together with the previous changes, yield the semantically most correct reconstructions. In the appendix we show that due to the triplet loss the nearest neighbour of (g) makes sense and yields a clearer reconstruction. The triplet loss without the PIRL is not sufficient and in Section 5 we show that the II-PIRL loss is the driving force for the improved performance.
+
+![](images/d2e3018806e7aeb40bb69ac24c26fbfc65654d09fd618bd03a61176a143b76ff.jpg)  
+Figure 6: Comparison of the training performance distribution for each epoch over 250 epochs. II-E-TAE is compared against training the corresponding extractor from scratch or fine-tuning the layers after the features which are used by the extractor in our autoencoder approach.
+
+# 4.7 KNN WITH TRIPLET LOSS OUT-PERFORMS FINE TUNED CLASSIFICATION MODELS
+
+We investigated whether the qualitative improvements also transfer to a quantitative improvement. We took the most basic approach: we combined the E-TAE with a k-nearest neighbor classifier in the latent space and used our new dataset for training. We retrieve the latent space vectors for all flipped training images as well and used only a single image per scene (i.e. not all 10 variations).√ We choose $k \stackrel { - } { = } \sqrt { N } = 1 1 5$ , where $N$ is the size of the training data together with its flipped version (Jirina et al., 2011). The model should classify occupancy (empty, infant, child or adult) for each seat position and we used the same hyperparameters for all methods and variations thereof. We froze the same layers of the pre-trained models for fine-tuning the later layers in case of classification models or to train our autoencoder using it as an extractor. We evaluated the model performance after each epoch on the real TICaM images (normal and flipped images of the training and test splits) for both the autoencoder and the corresponding classification model. This provides a measure on the best possible result for each method, but is of course not a valid approach for model selection. We report in Fig. 6 the training results for seeds 1 to 10 and summarize the training performance by plotting the mean and standard deviation per epoch per method. Our approach converges more robustly and consistently to a better mean accuracy. For each experiment, we retrieve the best accuracy across all epochs and compute the mean, standard deviation and maximum of these values across all runs: these statistics are reported in Table 2. See the appendix for training from scratch and Densenet121 results. The model weights corresponding to the epochs selected by the previous heuristics were applied on the SVIRO dataset to verify whether the learned representations are universally applicable to other vehicle interiors. For SVIRO, we used the training images and excluded all images containing empty child seats or empty infant seats, treated everyday objects as background. The results show that our E-AE significantly outperforms the classification models across three different pre-trained models and across all datasets. A consistent improvement for the different modifications is achieved: I-E-TAE outperforms E-TAE and II-E-TAE outperforms I-E-TAE.
+
+# 5 DISCUSSION AND LIMITATIONS
+
+We want to highlight that most of the contribution to the success of our introduced model variations stems from the novel II variation of the PIRL loss. To this end we trained several types of classifiers in the latent space of different autoencoder model variations and report the results in Table 3. The II variation of the PIRL loss largely improves the classification accuracy compared to the I variation. Moreover, the performance is better compared to the triplet loss variation which uses the label information explcitily as a latent space constraints, compared to the implicit use by the II-PIRL.
+
+Table 2: For each experiment, the best accuracy on real TICaM images across all epochs is taken and the mean, standard deviation and maximum of those values across all 10 runs is reported. The model weights achieving maximum performance per run on TiCAM are evaluated on SVIRO. Our approach outperforms the corresponding classification models significantly.   
+
+<table><tr><td></td><td></td><td colspan="2">TICaM</td><td colspan="2">SVIRO</td></tr><tr><td>Model</td><td>Variant</td><td>Mean</td><td>Max</td><td>Mean</td><td>Max</td></tr><tr><td>VGG-11</td><td>Pre-trained</td><td>75.5 ± 1.5</td><td>78.0</td><td>78.7± 2.9</td><td>84.0</td></tr><tr><td>Resnet-50</td><td>Pre-trained</td><td>78.1 ± 1.7</td><td>80.4</td><td>83.5 ± 2.7</td><td>88.1</td></tr><tr><td>VGG-11 Resnet-50</td><td>E-TAE E-TAE</td><td>76.7± 2.3 83.8 ± 1.3</td><td>81.5 86.0</td><td>78.6 ± 2.6 85.8± 2.4</td><td>82.3</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>89.1</td></tr><tr><td>VGG-11</td><td>I-E-TAE</td><td>79.7 ± 2.1</td><td>82.2</td><td>80.9 ± 4.0</td><td>85.6</td></tr><tr><td>Resnet-50</td><td>I-E-TAE</td><td>83.5 ± 1.3</td><td>85.6</td><td>89.2 ± 1.0</td><td>90.3</td></tr><tr><td>VGG-11</td><td>II-E-TAE</td><td>81.0± 0.6</td><td>82.0</td><td>79.1± 3.9</td><td>84.8</td></tr><tr><td>Resnet-50</td><td>II-E-TAE</td><td>83.7± 0.5</td><td>84.5</td><td>93.0± 0.8</td><td>94.1</td></tr></table>
+
+Table 3: For each of the 10 experimental runs per method after 250 epochs (i.e. not the best model weights per training were selected) and using the VGG-11 extractor we trained different classifiers in the latent space: $\mathbf { k }$ -nearest neighbour (KNN), random forest (RForest) and support vector machine with a linear kernel (SVM). The results show that most of the contribution to the synthetic to real generalization is due to the novel II variation of the PIRL cost function.   
+
+<table><tr><td></td><td colspan="3">TICaM</td><td colspan="3">SVIRO</td></tr><tr><td>Variant</td><td>KNN</td><td>RForest</td><td>SVM</td><td>KNN</td><td>RForest</td><td>SVM</td></tr><tr><td>E-AE</td><td>17.1 ± 6.7</td><td>24.2 ± 4.1</td><td>40.6 ± 8.5</td><td>38.7 ± 2.9</td><td>58.2 ± 2.0</td><td>72.9 ± 2.3</td></tr><tr><td>I-E-AE</td><td>18.2 ± 7.3</td><td>42.4± 6.5</td><td>50.1± 3.7</td><td>61.0 ± 3.5</td><td>72.2 ± 2.5</td><td>73.8 ± 2.3</td></tr><tr><td>II-E-AE</td><td>73.2 ± 3.9</td><td>68.8 ± 5.7</td><td>66.9 ± 6.7</td><td>83.7 ±1.9</td><td>79.8± 2.7</td><td>81.4± 2.2</td></tr><tr><td>E-TAE</td><td>69.2 ± 3.4</td><td>66.4± 4.0</td><td>68.7 ± 2.2</td><td>76.2 ± 2.3</td><td>71.2 ± 2.5</td><td>75.3 ± 2.5</td></tr></table>
+
+The II variation of the PIRL loss implicitly assumes that the classes are uni-modal, i.e. objects of the same class should be mapped onto a similar point in the latent space. This characteristic can either improve generalization or have a detrimental effect on the performance depending on the task to be solved. Under its current form there is no guarantee that, for example, facial landmarks or poses would be presereved. Nevertheless, we believe that extensions of our proposed loss, for example based on constraints (e.g. preservation of poses) could be an interesting direction for future work. It can be observed that our model is not perfect and sometimes struggles: e.g. in case an object (e.g. backpack) is located on the seat and for more complex human poses (e.g. people turning over). However, we believe that these problems are related to the training data: a more versatile synthetic dataset would probably improve the model performance on more challenging real images.
+
+Finally, we show that improvements reported in this work are not limited to the application in the vehicle interior. To this end, we trained models using the same design choices on MNIST LeCun et al. (1998) and evaluate the generalization onto real digits De Campos et al. (2009) in Fig. 12 and Table 10 in the appendix: similar improvements by the different design choices can be observed.
+
+# 6 CONCLUSION
+
+We introduced an autoencoder model which uses a pre-trained classification model as a feature extractor. Our results showed that the resulting model produces superior reconstructions for synthetic to real generalization. However, we highlighted that design choices made on simple datasets do not necessarily transfer to visually more complex tasks. We performed a step-by-step investigation of additional model changes and showcased the improvements of each change. Although only a simple $\mathbf { k }$ -nearest neigbor classifier is being used in the latent space, our proposed autoencoder model outperforms consistently and more robustly all classification model counterparts.
+
+# REPRODUCIBILITY STATEMENT
+
+Reproducibility of our results is ensured by the code implementation provided in the supplementary material. Moreover, the model weights for all results reported in this work are available for download (anonymously): see the readme file in the supplementary material for download links. This readme file also explains how the code implementation can be used and how the results of the paper can be reproduced. The code implementation contains all the evaluation scripts necessary to get the results reported in this work. The appendix contains additional details about the training and models details as well as the datasets and data pre-processing part. For the latter, we also implemented preprocessing functions for all datasets used in our work together with links to the different datasets to download them. The datasets used in this work are all publicly available. The newly created dataset used in this work is also readily available for download. Lastly, the licenses of all datasets used are detailed in the readme file as well.
+
+# CODE OF ETHICS
+
+Our proposed improvements on reducing the performance gap between synthetic and real images could reduce the necessity for human labelling and improve privacy since fewer human subjects are needed for data recordings. It would reduce the financial investment and time investment of companies, institutions and individuals. The question arises whether the usage of a pre-trained extractor introduces biases in the sub-sequent model, whether better disentanglement properties can be achieved and how it is affected by the choice of the latter. The first part of this work investigates model design choices on a simpler dataset without human subjects. The second part investigates the application in the vehicle interior. According to the authors of the TICaM dataset, written consent of the human participants was obtained together with their signature. Regarding the application in the vehicle interior - insights and improvements for the transfer from synthetic to real could be used to cover important edge cases (e.g. accidents) by simulations such that security and safety could be improved. The licenses for all publicly available datasets used in this work is referenced as well.
+
+# REFERENCES
+
+Ilge Akkaya, Marcin Andrychowicz, Maciek Chociej, Mateusz Litwin, Bob McGrew, Arthur Petron, Alex Paino, Matthias Plappert, Glenn Powell, Raphael Ribas, et al. Solving rubik’s cube with a robot hand. arXiv preprint arXiv:1910.07113, 2019.
+
+Vassileios Balntas, Edgar Riba, Daniel Ponsa, and Krystian Mikolajczyk. Learning local feature descriptors with triplets and shallow convolutional neural networks. In British Machine Vision Conference (BMVC), 2016.
+
+Paul Bergmann, Sindy Lowe, Michael Fauser, David Sattlegger, and Carsten Steger. Improving un- ¨ supervised defect segmentation by applying structural similarity to autoencoders. arXiv preprint arXiv:1807.02011, 2018.
+
+Alex Bewley, Jessica Rigley, Yuxuan Liu, Jeffrey Hawke, Richard Shen, Vinh-Dieu Lam, and Alex Kendall. Learning to drive from simulation without real world labels. In IEEE International Conference on Robotics and Automation (ICRA), 2019.
+
+Alexandra Carlson, Katherine A Skinner, Ram Vasudevan, and Matthew Johnson-Roberson. Sensor transfer: Learning optimal sensor effect image augmentation for sim-to-real domain adaptation. IEEE Robotics and Automation Letters (RA-L), 2019.
+
+Wuyang Chen, Zhiding Yu, Zhangyang Wang, and Animashree Anandkumar. Automated syntheticto-real generalization. In International Conference on Machine Learning (ICML, 2020.
+
+Teofilo Em ´ ´ıdio De Campos, Bodla Rakesh Babu, Manik Varma, et al. Character recognition in natural images. Proceedings of the International Conference on Computer Vision Theory and Applications (VISAPP), 2009.
+
+Steve Dias Da Cruz, Oliver Wasenmuller, Hans-Peter Beise, Thomas Stifter, and Didier Stricker. ¨ Sviro: Synthetic vehicle interior rear seat occupancy dataset and benchmark. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), 2020.
+
+Steve Dias Da Cruz, Bertram Taetz, Thomas Stifter, and Didier Stricker. Illumination normalization by partially impossible encoder-decoder cost function. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision (WACV), 2021.
+
+Steve Dias Da Cruz, Bertram Taetz, Oliver Wasenmuller, Thomas Stifter, and Didier Stricker. Au- ¨ toencoder based inter-vehicle generalization for in-cabin occupant classification. In IEEE Intelligent Vehicles Symposium (IV), 2021.
+
+Martin Engelcke, Adam R. Kosiorek, Oiwi Parker Jones, and Ingmar Posner. Genesis: Generative scene inference and sampling with object-centric latent representations. In International Conference on Learning Representations (ICLR), 2020.
+
+Kuan Fang, Yunfei Bai, Stefan Hinterstoisser, Silvio Savarese, and Mrinal Kalakrishnan. Multi-task domain adaptation for deep learning of instance grasping from simulation. In IEEE International Conference on Robotics and Automation (ICRA), 2018.
+
+Muhammad Waleed Gondal, Manuel Wuthrich, Djordje Miladinovic, Francesco Locatello, Martin Breidt, Valentin Volchkov, Joel Akpo, Olivier Bachem, Bernhard Scholkopf, and Stefan Bauer. ¨ On the transfer of inductive bias from simulation to the real world: a new disentanglement dataset. In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Fang Gongfan. Pytorch ms-ssim. https://github.com/VainF/pytorch-msssim, 2019.
+
+Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-vae: Learning basic visual concepts with a constrained variational framework. In International Conference on Learning Representations (ICLR), 2017.
+
+Stefan Hinterstoisser, Vincent Lepetit, Paul Wohlhart, and Kurt Konolige. On pre-trained image features and synthetic images for deep learning. In Proceedings of the European Conference on Computer Vision (ECCV) Workshops, 2018.
+
+Daniel Ho, Kanishka Rao, Zhuo Xu, Eric Jang, Mohi Khansari, and Yunfei Bai. Retinagan: An object-aware approach to sim-to-real transfer. arXiv preprint arXiv:2011.03148, 2020.
+
+Elad Hoffer and Nir Ailon. Deep metric learning using triplet network. In International Workshop on Similarity-Based Pattern Recognition (SIMBAD), 2015.
+
+Tadanobu Inoue, SLINEMOD ubhajit Choudhury, Giovanni De Magistris, and Sakyasingha Dasgupta. Transfer learning from synthetic to real images using variational autoencoders for precise position detection. In IEEE International Conference on Image Processing (ICIP), 2018.
+
+Marcel Jirina, MJ Jirina, and K Funatsu. Classifiers based on inverted distances. In New fundamental technologies in data mining, volume 1, pp. 369–387. InTech, 2011.
+
+Katie Kang, Suneel Belkhale, Gregory Kahn, Pieter Abbeel, and Sergey Levine. Generalization through simulation: Integrating simulated and real data into deep reinforcement learning for vision-based autonomous flight. In IEEE International Conference on Robotics and Automation (ICRA), 2019.
+
+Jigyasa Singh Katrolia, Bruno Mirbach, Ahmed El-Sherif, Hartmut Feld, Jason Rambach, and Didier Stricker. Ticam: A time-of-flight in-car cabin monitoring dataset, 2021.
+
+Hyunjik Kim and Andriy Mnih. Disentangling by factorising. In International Conference on Machine Learning (ICML), 2018.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. In International Conference on Learning Representations (ICLR), 2014.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 1998.
+
+Joonho Lee, Jemin Hwangbo, Lorenz Wellhausen, Vladlen Koltun, and Marco Hutter. Learning quadrupedal locomotion over challenging terrain. Science Robotics, 5(47), 2020.
+
+Xingang Pan, Ping Luo, Jianping Shi, and Xiaoou Tang. Two at once: Enhancing learning and generalization capacities via ibn-net. In Proceedings of the European Conference on Computer Vision (ECCV), 2018.
+
+Xingchao Peng, Ben Usman, Neela Kaushik, Judy Hoffman, Dequan Wang, and Kate Saenko. Visda: The visual domain adaptation challenge, 2017.
+
+Kanishka Rao, Chris Harris, Alex Irpan, Sergey Levine, Julian Ibarz, and Mohi Khansari. Rlcyclegan: Reinforcement learning aware simulation-to-real. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2020.
+
+David W. Romero and Mark Hoogendoorn. Co-attentive equivariant neural networks: Focusing equivariance on transformations co-occurring in data. In International Conference on Learning Representations (ICLR), 2020.
+
+Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojciech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 2017.
+
+Jonathan Tremblay, Aayush Prakash, David Acuna, Mark Brophy, Varun Jampani, Cem Anil, Thang To, Eric Cameracci, Shaad Boochoon, and Stan Birchfield. Training deep networks with synthetic data: Bridging the reality gap by domain randomization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, 2018.
+
+Sjoerd van Steenkiste, Francesco Locatello, Jurgen Schmidhuber, and Olivier Bachem. Are disen- ¨ tangled representations helpful for abstract visual reasoning? In Advances in Neural Information Processing Systems (NeurIPS), 2019.
+
+Xiangyu Yue, Yang Zhang, Sicheng Zhao, Alberto Sangiovanni-Vincentelli, Kurt Keutzer, and Boqing Gong. Domain randomization and pyramid consistency: Simulation-to-real generalization without accessing target domain data. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2019.
+
+Jingwei Zhang, Lei Tai, Peng Yun, Yufeng Xiong, Ming Liu, Joschka Boedecker, and Wolfram Burgard. Vr-goggles for robots: Real-to-sim domain adaptation for visual control. IEEE Robotics and Automation Letters (RA-L), 2019.
+
+Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Xi Zhang, Yanwei Fu, Shanshan Jiang, Leonid Sigal, and Gady Agam. Learning from synthetic data using a stacked multichannel autoencoder. In IEEE International Conference on Machine Learning and Applications (ICMLA), 2015.
+
+Wenshuai Zhao, Jorge Pena Queralta, and Tomi Westerlund. Sim-to-real transfer in deep reinforce- ˜ ment learning for robotics: a survey. In IEEE Symposium Series on Computational Intelligence (SSCI), 2020.
+
+# A APPENDIX
+
+# A.1 DATASET DETAILS
+
+If not specified otherwise, all images have been centre cropped and resized to 128 pixels.
+
+# A.1.1 MPI3D
+
+We used the synthetic realistic and toy images as well as the real images, but we restricted the dataset to use only large objects, since even for humans the small objects cannot always be distinguished reliably. The dataset can be downloaded from Github.
+
+# A.1.2 SVIRO
+
+We only used the grayscale training images from the SVIRO dataset. We considered everyday objects as background and removed all images containing empty child and infant seats. For the classification evaluation we used all the images from all the different vehicles, but we used training images only. Occupancy classification is performed on the entire image such that all three seats need to be classified simultaneously. Since four classes are available per seat (empty, infant seat, child seat and adult) this results in a total of $4 ^ { 3 } = 6 4$ classes. The dataset can be downloaded from their website.
+
+# A.1.3 SVIRO-ILLUMINATION
+
+For the classification evaluation we used all the training and test images from all the different vehicles. We used all the variations per scenes, i.e. not just a single variation per illumination variation. The dataset can be downloaded from their website.
+
+# A.1.4 OUR NEWLY RELEASED DATASET
+
+We created 2938 training and 2981 test sceneries where each scenery is rendered with 10 different backgrounds out of a pool of 450 backgrounds. The background and the corresponding illumination conditions were defined using high dynamic range images (HDRI). The latter were downloaded from https://hdrihaven.com/. Human models, child seats and infant seats were randomly placed as if they were located inside a vehicle, but no vehicle is visible. There are four possible classes for each seat position (empty, infant seat, child seat and adult) leading to a total of $4 ^ { 3 } = 6 4$ classes for the whole image. We created randomly 172 adults using http://www.makehumancommunity.org/ and we used 6 child seats and 7 infant seats which were textured using randomly one out of five textures. Since the dataset is synthetic, there are no consent and privacy concerns. We will release the dataset under the license CC BY-NC-SA 4.0. At the moment, it can be downloaded from this link (Google Drive - Anonymous user). Examples are visualized in Fig. 7. We noticed that a larger number of different human models increases the transferability to real images.
+
+# A.1.5 TICAM
+
+We used all training and test images and also flipped the images for the classification evaluation. This was done, because otherwise the class variability is quite low and there is a strong bias towards people sitting on the right driver seat. Moreover, the steering wheel would always be placed at the same right position. We also needed to perform some pre-processing to make the real TICaM images compatible with the synthetic images. First, we adapted the labels: we extracted the labels for the left and right seat from the filename. The file name is split at the character after which the third (right seat) and ninth (left seat) part is responsible for the class definition. If the latter was a 0 or contained an $o$ , we kept it as a 0. If it contained a $p$ , it was changed into a 3. We changed the value to 2 if it was one of the child seats s03, $s 1 3$ , $s 0 4$ , $s 1 4$ or the variation $g 0 0$ for the child seats $s 0 1$ , s11, s02, s12. In all other cases, it was transformed to a 1, i.e. for the child seats s05, s15, s06, $s 1 6$ and variations $g 0 1 g 1 1 g 1 0$ for s01, s11, s02, $s 1 2$ . Second, the illumination of the images was normalized using a histogram equalization. After that the images were cropped at height position 120 with height 300 and left position 106 with width 300. Finally, the images were resized to 128 pixels. The dataset can be downloaded from their website.
+
+![](images/ede576ee3ab39f781ba6de61b1d1324447567584a451def95a31a8e122ad430d.jpg)  
+Figure 7: Examples of sceneries with different backgrounds from the newly generated dataset.
+
+# A.2 TRAINING DETAILS
+
+All our experiments were conducted using PyTorch 1.8. Pre-defined and models pre-trained on Imagenet were taken from torchvision 0.9.0.
+
+We used the same hyperparameters for all training experiments and for all autoencoder and classification models respectively. We used the AdamW optimizer with a learning rate of $1 e - 4$ and weight decay of $1 e - 5$ . We used a batch size of 64 and the only augmentation performed was a random horizontal flip. All models were trained for 100 epochs on MPI3D and 250 epochs for the other datasets.
+
+Both the extractor autoencoder and the classification models used the same layer for extracting the features from the pre-trained models. In both cases and for all pre-trained models we used layer level $- 3$ in our implementation: those features were used to fine-tune the rest of the pretrained classification model or to train from scratch our added autoencoder layers. In all cases, we interpolated the input images to be of size 224 and copied the single grayscale image channel twice along the channel dimension.
+
+For the autoencoder training, we used the structural similarity index measure (SSIM) Bergmann et al. (2018) or the binary cross entropy (BCE) to measure the error between reconstruction and target image. We used PyTorch MS-SSIM Gongfan (2019) to compute the SSIM. In Eq. 5 we chose $\alpha = 1$ and $\beta = 1$ . We used a latent space dimension of 64 for all models trained on the vehicle interior and a latent space dimension of 10 for the MPI3D dataset. Further, we used the ReLU activation function. In case of a triplet loss, we used the swap parameter of Pytorch to make the negative mining more challenging Balntas et al. (2016). As a positive sample, we selected an image of a different scenery of the same class, i.e. the same objects are at the same seat position. For the negative sample we selected a scenery which differs in a single seat position and we did not allow sceneries with empty seats only. In case the partially impossible reconstruction loss was used, the target images for the positive and negative samples are chosen to be partially impossible as well.
+
+# A.2.1 MODEL DETAILS
+
+The autoencoder model architecture details are provided in Table 4, 6 and 7. Regarding the pretrained models, we used the output of the following layers to retrieve the extracted features. The notations is according to the torchvision model definitions:
+
+VGG-11   
+(16): Conv2d(512, 512, kernel_size $=$ (3, 3), stride $=$ (1, 1), padding $=$ (1, 1))   
+(17): ReLU(inplace=True)
+
+Resnet-50
+
+(5): Bottleneck( (conv1): Conv2d(1024, 256, kernel_size $=$ (1, 1), stride $=$ (1, 1), bias=False) (bn1): BatchNorm2d(256, eps=1e-05, momentum $_ { 1 = 0 }$ .1, affine=True, track_running_stats=True) (conv2): Conv2d(256, 256, kernel_size $=$ (3, 3), stride $=$ (1, 1), padding $=$ (1, 1), bias=False) (bn2): BatchNorm2d(256, ep $\displaystyle { \cdot \mathsf { s } } = 1 \mathsf { e } - 0 5$ , momentum $_ { 1 = 0 }$ .1, affine $=$ True, track_running_stats=True) (conv3): Conv2d(256, 1024, kernel_size $=$ (1, 1), stride $=$ (1, 1), bias=False) (bn3): BatchNorm2d(1024, eps $= 1 \mathrm { e } - 0 5$ , momentum=0.1, affine $=$ True, track_running_stats $=$ True) (relu): ReLU(inplace $=$ True)   
+)
+
+Densenet-121
+
+(denselayer24): _DenseLayer( (norm1): BatchNorm2d(992, eps ${ } , = { }$ 1e-05, momentum $\iota { = } 0 \cdot 1$ , affine $: =$ True, track_running_stat ${ \tt S } =$ True) (relu1): ReLU(inplace $=$ True) (conv1): Conv2d(992, 128, kernel_size $=$ (1, 1), stride $=$ (1, 1), bias=False) (norm2): BatchNorm2d(128, eps=1e-05, momentum $\iota { = } 0 \cdot 1$ , affine=True, track_running_stats=True) (relu2): ReLU(inplace $=$ True) (conv2): Conv2d(128, 32, kernel_size $=$ (3, 3), strid $: =$ (1, 1), padding $\bf { \dot { \alpha } } =$ (1, 1), bias $=$ False)   
+)
+
+Table 4: Model architecture for AE, VAE and $\beta$ -VAE on MPI3D   
+
+<table><tr><td>Encoder</td><td>Decoder</td></tr><tr><td>Input: 3 x 64 x 64</td><td>Input: 10</td></tr><tr><td>Conv, 4x4, 32, padding 1, stride 2 ReLU</td><td>FC,256, bias True ReLU</td></tr><tr><td>Conv, 4x4,32, padding 1, stride 2 ReLU</td><td>FC,1024,bias True ReLU</td></tr><tr><td>Conv, 4x4, 64, padding 1, stride 2 ReLU</td><td>ConvTranspose, 4x4,64, padding 1, stride 2 ReLU</td></tr><tr><td>Conv, 4x4, 64, padding 1, stride 2 ReLU</td><td>ConvTranspose, 4x4,32, padding 1, stride 2 ReLU</td></tr><tr><td>FC,256, bias True ReLU</td><td>ConvTranspose, 4x4, 32, padding 1, stride 2 ReLU</td></tr><tr><td>FC,10, bias True (twice in case of VAE)</td><td>ConvTranspose, 4x4, 3, padding 1, stride 2 Sigmoid</td></tr></table>
+
+Table 5: Model architecture for FactorVAE on MPI3D. The model is exactly the same as the VAE model and uses the following discriminator.   
+
+<table><tr><td rowspan=1 colspan=1>Discriminator</td></tr><tr><td rowspan=1 colspan=1>Input: 10</td></tr><tr><td rowspan=1 colspan=1>FC,1000,bias TrueLeakyReLU(0.2)</td></tr><tr><td rowspan=1 colspan=1>FC,1000, bias TrueLeakyReLU(0.2)</td></tr><tr><td rowspan=1 colspan=1>FC,1000, bias TrueLeakyReLU(0.2)</td></tr><tr><td rowspan=1 colspan=1>FC,1000,bias TrueLeakyReLU(0.2)</td></tr><tr><td rowspan=1 colspan=1>FC,1000, bias TrueLeakyReLU(0.2)</td></tr><tr><td rowspan=1 colspan=1>FC, 2, bias True</td></tr></table>
+
+Table 6: Model architecture for E-AE on MPI3D. The extractor is fixed during training.   
+
+<table><tr><td>Extractor + Summarizer + Encoder</td><td>Decoder</td></tr><tr><td>Input: 3 x 224 x 224</td><td>Input: 10</td></tr><tr><td>VGG-11 extractor after 7th Conv layer + ReLU Avgpool, 2x2, stride 2, padding 0</td><td>FC, 256, bias True ReLU</td></tr><tr><td>Conv, 4x4,256, padding 0, stride 1 ReLU</td><td>FC,1024,bias True ReLU</td></tr><tr><td>FC,256,bias True ReLU</td><td>ConvTranspose, 4x4, 64, padding 1, stride 2 ReLU</td></tr><tr><td>FC,10, bias True</td><td>ConvTranspose, 4x4,32, padding 1, stride 2 ReLU</td></tr><tr><td></td><td>ConvTranspose, 4x4, 32, padding 1, stride 2 ReLU</td></tr><tr><td></td><td>ConvTranspose,4x4,3, padding 1, stride 2 Sigmoid</td></tr></table>
+
+Table 7: Model architecture for E-AE on SVIRO, SVIRO-Illumination and TICaM. C is the channel dimension which is 1 for all datasets. The extractor is fixed during training.   
+
+<table><tr><td>Extractor+ Summarizer+ Encoder</td><td>Decoder</td></tr><tr><td>Input: C x 224 x 224</td><td>Input: 64</td></tr><tr><td>VGG-11 extractor after 7th Conv layer + ReLU Avgpool, 2x2, stride 2, padding 0</td><td>FC, 256, bias True ReLU</td></tr><tr><td>Conv, 4x4, 256, padding 0, stride 1 ReLU</td><td>FC, 4096,bias True ReLU</td></tr><tr><td>FC,256, bias True ReLU</td><td>ConvTranspose, 4x4, 64, padding 1, stride 2 ReLU</td></tr><tr><td>FC, 64, bias True</td><td>ConvTranspose, 4x4,32, padding 1, stride 2 ReLU</td></tr><tr><td></td><td>ConvTranspose, 4x4,32,padding 1, stride 2 ReLU</td></tr><tr><td></td><td>ConvTranspose, 4x4, C, padding 1, stride 2 Sigmoid</td></tr></table>
+
+![](images/9924c84adc4ef9be81f96a01eaad42978a62bc60065cb4e59248401a47ada55f.jpg)  
+Figure 8: t-SNE projection of the 10 dimensional latent space representation of the toy training (blue circle) together with the real (orange cross) images. Autoencoder (AE), $\beta$ Variational Autoencoder ( $\beta$ -VAE), FactorVAE and Extractor Autoencoder (E-AE). When trained on toy images, our extractor approach performs still best although the synthetic-real distributions are not as overlapped as if trained on realistic images.
+
+Table 8: We report the L1, SSIM and LIPIPS (Zhang et al., 2018) norm between the reconstructions of the real images (unknown) and the corresponding synthetic training images (realistic or toy). We report the mean of the norms across the entire reduced dataset: for SSIM larger $\uparrow$ and for the others smaller $\downarrow$ is better. E-AE performs best. Some models used SSIM, others BCE during training.   
+
+<table><tr><td>Trained on</td><td>Model</td><td>Variant</td><td>L1↓</td><td>SSIM↑</td><td>LPIPS↓</td></tr><tr><td>Toy</td><td>AE</td><td>BCE</td><td>768</td><td>0.559</td><td>0.412</td></tr><tr><td>Toy</td><td>AE</td><td>SSIM</td><td>932</td><td>0.558</td><td>0.347</td></tr><tr><td>Toy</td><td>E-AE (ours)</td><td>BCE</td><td>291</td><td>0.896</td><td>0.095</td></tr><tr><td>Toy</td><td>E-AE (ours)</td><td>SSIM</td><td>177</td><td>0.899</td><td>0.103</td></tr><tr><td>Toy</td><td>VAE</td><td>BCE</td><td>659</td><td>0.497</td><td>0.338</td></tr><tr><td>Toy</td><td>β-VAE</td><td>BCE,β= 4</td><td>710</td><td>0.527</td><td>0.311</td></tr><tr><td>Toy</td><td>β-VAE</td><td>BCE,β=8</td><td>406</td><td>0.709</td><td>0.258</td></tr><tr><td>Toy</td><td>FactorVAE</td><td>BCE,=10</td><td>521</td><td>0.660</td><td>0.262</td></tr><tr><td>Toy</td><td>FactorVAE</td><td>BCE, = 30</td><td>447</td><td>0.710</td><td>0.344</td></tr><tr><td>Toy</td><td>FactorVAE</td><td>BCE,γ = 50</td><td>430</td><td>0.712</td><td>0.221</td></tr><tr><td>Realistic</td><td>AE</td><td>BCE</td><td>373</td><td>0.841</td><td>0.211</td></tr><tr><td>Realistic</td><td>AE</td><td>SSIM</td><td>568</td><td>0.832</td><td>0.195</td></tr><tr><td>Realistic</td><td>E-AE (ours)</td><td>BCE</td><td>220</td><td>0.917</td><td></td></tr><tr><td>Realistic</td><td>E-AE (ours)</td><td>SSIM</td><td>251</td><td>0.921</td><td>0.071</td></tr><tr><td>Realistic</td><td>VAE</td><td>BCE</td><td>482</td><td>0.740</td><td>0.081</td></tr><tr><td>Realistic</td><td>β-VAE</td><td>BCE,β= 4</td><td>372</td><td>0.810</td><td>0.197</td></tr><tr><td>Realistic</td><td>β-VAE</td><td>BCE,β=8</td><td>384</td><td>0.794</td><td>0.176</td></tr><tr><td></td><td>FactorVAE</td><td>BCE,γ= 10</td><td>218</td><td>0.880</td><td>0.189</td></tr><tr><td>Realistic</td><td>FactorVAE</td><td>BCE,  = 30</td><td>244</td><td>0.862</td><td>0.151</td></tr><tr><td>Realistic</td><td></td><td></td><td>391</td><td></td><td>0.161</td></tr><tr><td>Realistic</td><td>FactorVAE</td><td>BCE,γ = 50</td><td></td><td>0.779</td><td>0.164</td></tr></table>
+
+![](images/de052ac8418571befb4990a43a6c1c6ce17b9723fd012ea1b9a9278659938097.jpg)  
+(a) Reconstruction of training data when being trained on realistic data.
+
+![](images/8dc8fb9439a9eb337dec11411c741edb66a8f3da019bc395d49084f900c41b13.jpg)  
+Figure 9: Reconstruction of realistic and toy training data for different autoencoders: Autoencoder (AE), $\beta$ Variational Autoencoder ( $\beta$ -VAE), FactorVAE (F-VAE) and Extractor Autoencoder (E-AE).
+
+(b) Reconstruction of training data when being trained on toy data.
+
+Table 9: For each experiment, the best performance (in percentage) on real vehicle interior images (TICaM) across all epochs is taken and then the mean and maximum of those values across all 10 runs is reported. For the same backbone model extractor, our approach outperforms the vanilla classification models significantly. The model weights achieving the maximum performance per run are also evaluated on SVIRO where they perform better as well.
+
+<table><tr><td></td><td>Dataset</td><td colspan="2">TICaM</td><td colspan="2">SVIRO</td></tr><tr><td></td><td>Dataset size</td><td>13356</td><td></td><td>11959</td><td></td></tr><tr><td>Model</td><td>Variant</td><td>Mean</td><td>Max</td><td>Mean</td><td>Max</td></tr><tr><td>VGG-11</td><td>Scratch</td><td>58.5 ± 4.0</td><td>64.6</td><td>65.6 ± 5.4</td><td>72.7</td></tr><tr><td>Resnet-50</td><td>Scratch</td><td>53.3 ± 3.5</td><td>60.4</td><td>56.4 ± 2.6</td><td>59.3</td></tr><tr><td>Densenet-121</td><td>Scratch</td><td>56.3 ± 5.5</td><td>62.1</td><td>68.8± 2.4</td><td>74.9</td></tr><tr><td>VGG-11</td><td>Pre-trained</td><td>75.5 ± 1.5</td><td>78.0</td><td>78.7± 2.9</td><td>84.0</td></tr><tr><td>Resnet-50</td><td>Pre-trained</td><td>78.1 ± 1.7</td><td>80.4</td><td>83.5 ± 2.7</td><td>88.1</td></tr><tr><td>Densenet-121</td><td>Pre-trained</td><td>72.2 ± 4.2</td><td>77.4</td><td>85.0 ± 2.3</td><td>88.0</td></tr><tr><td>VGG-11</td><td>E-TAE</td><td>76.7 ± 2.3</td><td>81.5</td><td>78.6 ± 2.6</td><td>82.3</td></tr><tr><td>Resnet-50</td><td>E-TAE</td><td>83.8 ± 1.3</td><td>86.0</td><td>85.8 ± 2.4</td><td>89.1</td></tr><tr><td>Densenet-121</td><td>E-TAE</td><td>78.5 ± 2.4</td><td>81.8</td><td>86.7 ± 1.3</td><td>88.2</td></tr><tr><td>VGG-11</td><td>I-E-TAE</td><td>79.7 ± 2.1</td><td>82.2</td><td>80.9 ± 4.0</td><td>85.6</td></tr><tr><td>Resnet-50</td><td>I-E-TAE</td><td>83.5 ± 1.3</td><td>85.6</td><td>89.2 ± 1.0</td><td>90.3</td></tr><tr><td>Densenet-121</td><td>I-E-TAE</td><td>77.2 ± 1.7</td><td>79.3</td><td>90.4 ± 1.3</td><td>92.1</td></tr><tr><td>VGG-11</td><td>II-E-TAE</td><td>81.0 ± 0.6</td><td>82.0</td><td>79.1 ± 3.9</td><td>84.8</td></tr><tr><td>Resnet-50</td><td>II-E-TAE</td><td>83.7 ± 0.5</td><td>84.5</td><td>93.0 ± 0.8</td><td>94.1</td></tr><tr><td>Densenet-121</td><td>II-E-TAE</td><td>79.3 ± 1.3</td><td>81.5</td><td>89.9 ± 1.8</td><td>92.3</td></tr></table>
+
+![](images/ad6b959581948049348901aa328ca18fa4ad72ebd2d1172c214851fcdfc96631.jpg)  
+Figure 10: Reconstruction results of unseen real data (a) from the TICaM dataset: (b) E-AE Trained on Tesla SVIRO, (c) E-AE Trained on Kodiaq SVIRO-Illumination , (d) I-E-AE Trained on Kodiaq SVIRO-Illumination , (e) E-AE, (f) I-E-AE, (g) II-E-AE, (h) E-TAE, (i) I-E-TAE, (j) II-E-TAE and (k) Nearest neighbour of (j). Examples (e)-(k) are all trained on our new dataset. A red (wrong) or green (correct) box highlights whether the semantics are preserved by the reconstruction.
+
+Table 10: Different model architecture variations trained on MNIST. Then different classifiers were trained on the latent space representation of the training data and evaluated on real images of digits. Models were trained for 20 epochs using a latent dimension of 64 and MSE reconstruction loss. See Fig. 12 for the corresponding reconstruction results and input images.   
+
+<table><tr><td>Model</td><td>KNN</td><td>RForest</td><td>SVM</td></tr><tr><td>AE</td><td>15.7</td><td>12.5</td><td>11.6</td></tr><tr><td>TAE</td><td>11.1</td><td>11.6</td><td>8.4</td></tr><tr><td>II-AE II-TAE</td><td>27.8 21.8</td><td>20.2 17.9</td><td>23.6 23.9</td></tr><tr><td>E-AE E-TAE</td><td>27.3</td><td>23.1</td><td>26.5</td></tr><tr><td></td><td>26.1</td><td>19.1</td><td>23.3</td></tr><tr><td>II-E-AE</td><td>65.</td><td>61.9</td><td>65.6</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>II-E-TAE</td><td>64.1</td><td>63.7</td><td>63.7</td></tr></table>
+
+![](images/2fd75823d393d13fa0676f4e49df10819d578f94fac364788433f9a3f8ab6fa9.jpg)  
+Figure 11: Comparison of the training performance distribution for each epoch over 250 epochs. II-E-TAE is compared against training the corresponding extractor from scratch or fine-tuning the layers after the features which are used by the extractor in our autoencoder approach.
+
+![](images/65ab66f3264425dbc2e561d14109b514e805afe8278d6c69e65be9b64fb7b395.jpg)  
+Figure 12: Reconstruction of real input images of digits by models trained on MNIST. Similar to the vehicle interior, the II-PIRL loss provides the best class preserving reconstructions. The latter is supported by the quantiative results in Table 10.