Add files using upload-large-folder tool

parse/dev/4G1Sfp_1sz7/4G1Sfp_1sz7_content_list.json

@@ -0,0 +1,1396 @@
+[
+    {
+        "type": "text",
+        "text": "Generating Training Data with Language Models: Towards Zero-Shot Language Understanding ",
+        "text_level": 1,
+        "bbox": [
+            200,
+            122,
+            803,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yu Meng, Jiaxin Huang, Yu Zhang, Jiawei Han Department of Computer Science, University of Illinois at Urbana-Champaign {yumeng5,jiaxinh3,yuz9,hanj}@illinois.edu ",
+        "bbox": [
+            241,
+            224,
+            754,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            303,
+            535,
+            319
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pretrained language models (PLMs) have demonstrated remarkable performance in various natural language processing tasks: Unidirectional PLMs (e.g., GPT) are well known for their superior text generation capabilities; bidirectional PLMs (e.g., BERT) have been the prominent choice for natural language understanding (NLU) tasks. While both types of models have achieved promising few-shot learning performance, their potential for zero-shot learning has been underexplored. In this paper, we present a simple approach that uses both types of PLMs for fully zero-shot learning of NLU tasks without requiring any task-specific data: A unidirectional PLM generates class-conditioned texts guided by prompts, which are used as the training data for fine-tuning a bidirectional PLM. With quality training data selected based on the generation probability and regularization techniques (label smoothing and temporal ensembling) applied to the fine-tuning stage for better generalization and stability, our approach demonstrates strong performance across seven classification tasks of the GLUE benchmark (e.g., 72.3/73.8 on MNLI- $. \\mathrm { m } / \\mathrm { m m }$ and 92.8 on SST-2), significantly outperforming zero-shot prompting methods and achieving even comparable results to strong few-shot approaches using 32 training samples per class1. ",
+        "bbox": [
+            233,
+            335,
+            766,
+            563
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            310,
+            608
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pretrained language models (PLMs) [5, 8, 11, 19, 34, 40, 41] have achieved human-level performance on natural language understanding (NLU) tasks [66, 67] when fine-tuned on a large amount of task-specific training data. However, such a supervised fine-tuning paradigm is drastically different from how humans perform these tasks: We barely need to see many task-specific training samples to perform well. Recently, many studies have revealed the intriguing few-shot learning potential of PLMs: By converting task descriptions to natural language prompts and injecting them into PLMs, prompt-based approaches [5, 13, 55, 56, 59] leverage task-specific information for better training data efficiency and have achieved remarkable few-shot results. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            731
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When prompt-based methods are applied to the zero-shot setting, however, the PLMs’ predictions are much less accurate. For example, GPT-3’s zero-shot performance is much degraded relative to its few-shot performance [5], especially on challenging tasks like natural language inference (NLI). Without any task-specific samples, it is indeed challenging for PLMs to effectively interpret the prompts that come in different formats and are unseen in the pretraining data. To familiarize PLMs with various prompts for zero-shot generalization to unseen tasks, a recent study proposes instruction tuning [70], which fine-tunes PLMs on a large collection of different tasks described by instructions. Despite its strong performance, its success is grounded in the large number of cross-task annotated datasets (e.g., train on many non-NLI tasks and transfer to NLI tasks) and the gigantic model size (e.g., hundreds of billions of parameters), posing great challenges for training and using them. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            869
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we study zero-shot learning of PLMs on NLU tasks without any task-specific or crosstask data. Motivated by the strong text generation power of recent PLMs [5, 23, 30, 52], we propose SuperGen, a Supervision Generation approach, wherein training data are created via a unidirectional PLM (i.e., the generator) which generates class-conditioned texts guided by label-descriptive prompts. A bidirectional PLM (i.e., the classifier) is then fine-tuned on the generated texts to perform the corresponding task. Both PLMs can be of moderate size to fit in typical research hardware (e.g., a GPT-2-sized [51] generator and a RoBERTaLarge-sized [34] classifier). With supervision automatically created by the generator, SuperGen eliminates the need for task-specific annotations and provides the classifier PLM with a larger amount of training data than in few-shot scenarios. We call such a setting zero-shot because the entire process does not need any human annotated data, either from the target task or other tasks. The major difference from previous methods is that we synthesize training data for the target task, whereas existing zeros-shot methods do not use any form of training data from the test domain (but may train on other domains) and directly perform inference on the target task. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Across seven classification tasks of the GLUE benchmark [66], SuperGen significantly outperforms the prompt-based zero-shot method and even achieves an overall better result in both average performance and stability than strong few-shot approaches that use 32 annotated samples per class. We identify several key factors to the strong performance of SuperGen through ablation studies: (1) selecting quality training data based on their generated probability, and (2) using label smoothing and temporal ensembling to regularize fine-tuning on generated data. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            351
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            371,
+            321,
+            387
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Few-Shot and Zero-Shot Learning with PLMs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            402,
+            532,
+            417
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Instead of using a large amount of annotated training data for fine-tuning PLMs on downstream tasks, few-shot learning studies how to better leverage only a small amount of task-specific training data, a more realistic scenario in many applications. The most strict few-shot learning setting does not assume access to any unlabeled data or large validation sets for hyperparameter tuning [48], where prompt-based methods [5, 13, 33, 35, 55–57, 59, 63, 84] are prominently deployed to inject task descriptions into PLMs and make effective use of their language modeling capability for improved training data efficiency in low-data regimes. More broadly, semi-supervised learning additionally leverages unlabeled task-specific data, where data augmentation [7, 73], regularization [43] and bootstrapping [56] methods are commonly used. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot learning, on the other hand, is a much more challenging setting with absolutely no access to any task-specific data. When prompt-based methods are directly used to obtain predictions from PLMs without any training, their zero-shot performance can be much worse [5, 13]—difficult NLU tasks can be barely formulated as prompts that resemble the format of pretraining data, posing great challenges for PLMs to accurately interpret and leverage the prompts without given any training samples. The current mainstream of zero-shot learning is based on transfer learning: By converting a set of tasks with abundant annotations into instruction templates [42, 54, 70, 74], entailment pairs [79, 80] or question-answer formats [50, 86] and fine-tuning PLMs on them, the PLMs acquire the cross-task transfer ability [78] to execute unseen tasks when they are formulated in a similar format. Our work proposes a different approach from these studies: We use a unidirectional PLM to generate training data for fine-tuning another PLM on the target task. This not only removes the need for a large amount of cross-task annotations, but also eliminates the task difference in training and inference. Moreover, different from previous studies [1, 76] that rely on labeled data to fine-tune the generative PLM, we directly use prompts to guide data generation without fine-tuning. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            741
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Controlled Text Generation with PLMs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            758,
+            486,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Controlled text generation [22] aims to steer the generated texts of language models towards desired contents, styles or domains. Through fine-tuning PLMs on attribute-specific data, high-level control (e.g., generating certain topics or sentiments [88]), fine-grained control (e.g., generating specific words or phrases [6]) or both [24] can be achieved. Adapting PLMs to generate texts of specific attributes can also be realized at inference time without any further training of the PLMs [10, 26, 27, 32, 47, 75]. Different text attributes can also be represented during pretraining time as control codes [23] which later can serve as explicit guidance for generating domain/attribute-specific texts. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            878
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The idea of generating category-conditioned texts as training data has been explored for topic classification with bag-of-words or LSTM-based language models [38, 39], which may not have enough capacity to generate quality training data for challenging NLU tasks. With more powerful PLMs, the idea of using prompts as guidance has emerged recently: Since natural language generation is largely based on contexts, using certain prompts to start a sequence can effectively steer the subsequent texts to be generated. The prompts can be either in natural language [57] or as learnable parameters [31]. In this work, we also guide text generation via prompts, but for the novel purpose of creating training data for NLU tasks. There have been studies with similar goals, such as generating similar/dissimilar sentences for training sentence embeddings [58] and using labeled samples as demonstrations to prompt large PLMs [81] for creating novel training data. In this work, we explore generating training data without using any labeled samples for a wide range of different NLU tasks. The similar setting is also explored in a concurrent study [77]. Compared to annotated task-specific data, the generated texts may contain noise and have domain difference from the downstream task. We introduce several important strategies for effective fine-tuning on generated data. ",
+        "bbox": [
+            174,
+            883,
+            820,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/801aec59c9633f7891b483be336be9aeac6c924769ec046dea1586f20d530364.jpg",
+        "image_caption": [
+            "Figure 1: Overview of SuperGen for zero-shot learning of NLU tasks. A unidirectional PLM generates training data guided by label-descriptive prompts. Quality training samples are selected based on average log generation probability. A bidirectional PLM is fine-tuned on the selected training set with label smoothing and temporal ensembling as regularization to perform the classification task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            88,
+            823,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            305,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            484,
+            271,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            307,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Problem Formulation. We consider solving a classification problem2 where we are only given the label space $\\mathcal { V }$ and a mapping $\\mathcal { M } : \\mathcal { V } \\to \\mathcal { W }$ that converts each label $y \\in \\mathcal { V }$ into a label-descriptive prompt (i.e., a short phrase) $\\pmb { w } _ { y } \\in \\mathcal { W }$ . We assume access to a unidirectional PLM $G _ { \\theta }$ as the generator and a bidirectional PLM $C _ { \\phi }$ which will be fine-tuned as the classifier3. We also assume the pretraining corpus $\\mathcal { D }$ (e.g., Wikipedia) is available. Fig. 1 shows an overview of our proposed SuperGen method. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Text Generation with Unidirectional PLMs. A unidirectional PLM $G _ { \\theta }$ is pretrained to maximize the generation probability of each token in a sequence $\\pmb { x } = [ x _ { 1 } , x _ { 2 } , \\dots , x _ { n } ]$ conditioned on previous tokens: ",
+        "bbox": [
+            174,
+            622,
+            825,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4ea019cf8dc0d19f06b9134c4c0567944a1393816001656c406caffe618eada9.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\theta } \\prod _ { i = 1 } ^ { n } p _ { \\theta } ( x _ { i } | \\pmb { x } _ { < i } ) , \\quad \\mathrm { w h e r e } \\quad p _ { \\theta } ( x _ { i } | \\pmb { x } _ { < i } ) = \\frac { \\exp ( e _ { i } ^ { \\top } h _ { i } ) } { \\sum _ { j = 1 } ^ { | V | } \\exp ( e _ { j } ^ { \\top } h _ { i } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            659,
+            717,
+            700
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $p _ { \\theta } ( \\cdot )$ is usually parameterized using token embeddings $e$ and contextualized embeddings $^ { h }$ given by a Transformer [65] encoder. ",
+        "bbox": [
+            176,
+            704,
+            823,
+            731
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After pretraining, $G _ { \\theta }$ can be directly used to generate new texts by recursively sampling tokens from its output probability distribution. Typically, a temperature hyperparameter $\\tau > 0$ is introduced during sampling [20] to adjust the sharpness of the probability distribution: ",
+        "bbox": [
+            174,
+            737,
+            825,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/35046ab374c4ecaa3bf95be7bb40f4a99dbcd7f2284937d9d6c6e9064296eb64.jpg",
+        "text": "$$\np _ { \\theta } ( x _ { i } | \\pmb { x } _ { < i } ) = \\frac { \\exp ( \\pmb { e } _ { i } ^ { \\top } \\pmb { h } _ { i } / \\tau ) } { \\sum _ { j = 1 } ^ { | V | } \\exp ( \\pmb { e } _ { j } ^ { \\top } \\pmb { h } _ { i } / \\tau ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            784,
+            619,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau  0$ approximates greedily picking the most probable next token; $\\tau  \\infty$ induces a uniform distribution. Additionally, sampled tokens can be confined to the top- $k$ most probable ones to avoid low-quality tokens. In this work, we find such top- $k$ sampling with temperature is sufficient to produce coherent and meaningful texts as training data for NLU tasks. Exploring more sophisticated sampling strategies [21] is left for future work. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Training Data Generation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            174,
+            393,
+            189
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When given a label-descriptive prompt such as “Write a negative review:”, humans are able to produce texts pertaining to the corresponding class. We aim to leverage the strong text generation power of a unidirectional PLM $G _ { \\theta }$ for the same purpose of creating class-conditioned training data. We note that $G _ { \\theta }$ is directly used for generation without any parameter updates. The prompts used for different NLU tasks in GLUE are summarized in Table 1. ",
+        "bbox": [
+            174,
+            200,
+            460,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Prompts used to generate class-conditioned texts for different GLUE tasks. SST-2 is a singlesequence classification task and the rest are sequencepair classification tasks. Generation for CoLA does not use prompts but by varying sampling temperatures. $\\pmb { x } ^ { s }$ denotes a sequence randomly sampled from the pretraining corpus; $\\pmb { x } ^ { g }$ denotes the sequence to be generated by $G _ { \\theta }$ ; . . . denotes skipping at least one sequence. See Appendix A for more details. ",
+        "bbox": [
+            473,
+            217,
+            825,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generating Single Sequences. For singlesequence NLU tasks such as sentiment classification (e.g., SST-2), we simply use a prompt ${ \\pmb w } _ { y }$ corresponding to label $y$ as the beginning of the sequence and let $G _ { \\theta }$ generate the remaining sequence: ",
+        "bbox": [
+            174,
+            362,
+            462,
+            441
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/82013981c11d0105a5c123c78a5c772fc6646323377b6c0f05be15d5c3dbc260.jpg",
+        "text": "$$\n\\pmb { x } ^ { g }  G _ { \\theta } ( \\pmb { w } _ { y } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            448,
+            369,
+            465
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/d8efbe91ba3ca13d3ce17994d446978c773acdd66363dec700bb3a9ef3b796d4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Label</td><td>Prompt</td></tr><tr><td>SST-2</td><td>positive negative</td><td>Rating:5.0xg Rating: 1.0 xg</td></tr><tr><td rowspan=\"4\">MNLI</td><td>entailment</td><td>x.In other words,xg</td></tr><tr><td>neutral</td><td>x.Furthermore,xg</td></tr><tr><td></td><td>There is a rumor that x.</td></tr><tr><td>contradiction</td><td>However, the truth is:x9</td></tr><tr><td rowspan=\"2\">QNLI</td><td>entailment</td><td>x？xg</td></tr><tr><td>not entailment</td><td>x？...g</td></tr><tr><td rowspan=\"2\">RTE</td><td>entailment</td><td>x.In other words,xg</td></tr><tr><td>not entailment</td><td>x.Furthermore,xg</td></tr><tr><td rowspan=\"2\">MRPC</td><td>equivalent</td><td>x.In other words,xg</td></tr><tr><td>not equivalent</td><td>x.Furthermore,xg</td></tr><tr><td rowspan=\"2\">QQP</td><td>equivalent</td><td>x ?In other words,xg</td></tr><tr><td>not equivalent</td><td>x&quot;?Furthermore,xg</td></tr></table>",
+        "bbox": [
+            485,
+            349,
+            807,
+            568
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $G _ { \\theta } ( \\pmb { w } _ { y } )$ denotes using ${ \\pmb w } _ { y }$ as the input to $G _ { \\theta }$ and recursively sampling tokens from the distribution in Eq. (1) until a full sequence is generated; $\\pmb { x } ^ { g }$ denotes the generated sequence (i.e., excluding the prompt), which will be paired with $y$ to form one training sample $( \\bar { \\pmb { x } ^ { g } } , y )$ . ",
+        "bbox": [
+            174,
+            470,
+            462,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For syntactic tasks like linguistic acceptabil  \nity classification (e.g., CoLA) which requires generating both linguistically acceptable and unacceptable sequences, we start the sequence with random stop words and use varying sampling temperatures for generating different sequences. A smaller temperature (e.g., $\\tau = 0 . 1$ in Equation (1)) sharpens the sampling probability distribution towards the most probable tokens, thus the resulting sequence is more likely to be linguistically acceptable. Using a larger temperature (e.g., $\\tau = 1 0$ in Equation (1)) flattens the sampling probability distribution to be more uniform, and the generated tokens will be nearly random, which can create linguistically incorrect sequences. ",
+        "bbox": [
+            173,
+            570,
+            825,
+            678
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Generating Sequence Pairs. Sequence-pair classification tasks require generating two sequences of specific relationships (e.g., entailment, contradiction). We sample4 the first sequence $\\pmb { x } ^ { s }$ from the pretraining corpus $\\mathcal { D }$ , concatenate the prompt ${ \\pmb w } _ { y }$ with $\\pmb { x } ^ { s }$ , and generate the second sequence $\\pmb { x } ^ { g }$ : ",
+        "bbox": [
+            174,
+            691,
+            825,
+            736
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5a34cddbb0c98ba688bf088e5cd1510fd7fe65d222ede02c2b0fb1e1f311e90c.jpg",
+        "text": "$$\n\\pmb { x } ^ { g }  G _ { \\theta } ( [ \\pmb { x } ^ { s } ; \\pmb { w } _ { y } ] ) , \\pmb { x } ^ { s } \\sim \\mathcal { D } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            741,
+            601,
+            758
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The sequence pair training sample will then be formed as $( \\pmb { x } ^ { s } , \\pmb { x } ^ { g } , y )$ . ",
+        "bbox": [
+            174,
+            763,
+            629,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Rewarding and Penalizing Repetitions for Sequence Pair Generation. A common issue in text generation is degenerate repetition [21, 23, 51, 71] where generated texts get stuck in repetition loops. To address this issue, one approach is to discourage repetition by reducing the logits of tokens that are already in the sequence before performing sampling [23]. In sequence pair generation, however, it is sometimes desirable to encourage the second sequence to repeat some words in the first sentence (e.g., for generating an entailment or a paraphrase). Therefore, we propose a simple modification of ",
+        "bbox": [
+            173,
+            792,
+            826,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Eq. (1) that rewards/penalizes repetition based on whether the token has appeared in ${ \\pmb x } ^ { s } / { \\pmb x } ^ { g }$ : ",
+        "bbox": [
+            168,
+            90,
+            774,
+            107
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d57175c5233cf8f601547d96b55f8ae3dc8fff22d6a3bd03d7e902ada91869a.jpg",
+        "text": "$$\np _ { \\theta } ( x _ { i } | \\boldsymbol x _ { < i } ) = \\frac { \\exp ( e _ { i } ^ { \\top } h _ { i } / \\omega ) } { \\sum _ { j = 1 } ^ { | V | } \\exp ( e _ { j } ^ { \\top } h _ { i } / \\omega ) } , \\quad \\mathrm { w h e r e } \\quad \\omega = \\left\\{ \\begin{array} { l l } { \\tau \\alpha } & { x _ { i } \\in \\boldsymbol x ^ { s } \\wedge x _ { i } \\not \\in \\boldsymbol x ^ { g } } \\\\ { \\tau \\beta } & { x _ { i } \\in \\boldsymbol x ^ { g } } \\\\ { \\tau } & { \\mathrm { e l s e } } \\end{array} \\right. ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            113,
+            764,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "and $\\alpha > 0 , \\beta > 0$ are hyperparameters. By setting $\\alpha < 1$ and $\\beta > 1$ , we can promote tokens in $\\mathbf { \\Delta } \\mathbf { \\mathbf { x } } ^ { s }$ that have not appeared in $\\pmb { x } ^ { g }$ to have a higher chance of being generated, and discourage the generation of repetitive tokens in $\\pmb { x } ^ { g }$ to mitigate degenerate repetition. The parameters used for different tasks are listed in Appendix B Table 9. ",
+        "bbox": [
+            173,
+            169,
+            825,
+            224
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Effective Fine-Tuning on Generated Texts ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            241,
+            504,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With the generated training data, one can fine-tune a bidirectional PLM $C _ { \\phi }$ as the classifier to perform the NLU task. However, training $C _ { \\phi }$ via standard supervised training on all generated texts is likely to yield suboptimal performance on downstream tasks because (1) the generated texts may contain noise as $G _ { \\theta }$ may not always produce texts pertaining to the desired class, especially for challenging sequence pair tasks with subtle semantic relationships; and (2) the generated texts can be considered as originated from the domain of $G _ { \\theta }$ ’s pretraining data, with a potentially different distribution from the downstream task; straightforward application of supervised training will result in overfitting to the pretraining domain and diminishing generalization ability, a common challenge in transfer learning [64, 87]. To address these challenges, we next introduce several simple and important strategies for more effective and stable fine-tuning on generated texts. ",
+        "bbox": [
+            173,
+            266,
+            826,
+            401
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Selecting Quality Training Data. We aim to select generated texts $\\pmb { x } ^ { g }$ that are most likely to pertain to the desired label $y$ (i.e., with the highest $p ( \\boldsymbol { x } ^ { g } | \\boldsymbol { y } ) )$ . The true probability $p ( \\pmb { x } ^ { g } | y )$ is unknown and we estimate it via the generation probability given by $G _ { \\theta }$ conditioned on the prompt ${ \\pmb w } _ { y }$ : ",
+        "bbox": [
+            173,
+            416,
+            823,
+            459
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1eda1e786bda2f4a5406657ee623fb1064988ae96b7efde4b6494c88a2d1c531.jpg",
+        "text": "$$\np ( \\pmb { x } ^ { g } | y ) \\approx p _ { \\theta } ( \\pmb { x } ^ { g } | \\pmb { w } _ { y } ) = \\prod _ { i = 1 } ^ { n } p _ { \\theta } \\left( x _ { i } \\big | [ \\pmb { w } _ { y } ; \\pmb { x } _ { < i } ^ { g } ] \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            465,
+            658,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since the above measure is biased towards shorter sequences, we instead use the geometric mean of the above conditional generation probability (or equivalently, the average log probability) of all tokens in $\\pmb { x } ^ { g }$ as the ranking score, following [82]: ",
+        "bbox": [
+            173,
+            512,
+            825,
+            553
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/86f9fac3e246b32d8b3749b1b8e7b8ddd5e72107889873d0ff1afbb5bb81742e.jpg",
+        "text": "$$\nr = \\frac { 1 } { n } \\sum _ { i = 1 } ^ { n } \\log p _ { \\theta } \\left( x _ { i } \\middle | [ \\pmb { w } _ { y } ; \\pmb { x } _ { < i } ^ { g } ] \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            559,
+            611,
+            601
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To construct a training set consisting of $N$ samples per class, we will generate more samples (e.g., $1 0 N )$ ), and select training data based on the score $r$ in Eq. (3): For all tasks except CoLA, the top- $N$ ones of each class are selected; for CoLA, the top- $N$ ones are used as linguistically acceptable training samples, and the bottom- $N$ ones as linguistically unacceptable sequences. ",
+        "bbox": [
+            173,
+            606,
+            825,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Regularization for Better Generalization and Stability. Even with the above training data selection procedure, the resulting training set may still contain noise and there exists domain difference from the downstream tasks. We apply two regularization techniques, label smoothing [62] and temporal ensembling [28] for better fine-tuning stability and generalization. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            731
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given a training sample $( \\boldsymbol { x } ^ { g } , \\boldsymbol { y } )$ , label smoothing trains the classifier $C _ { \\phi }$ to minimize the standard cross-entropy loss between the label and the classifier’s prediction $p _ { \\phi } ( \\pmb { x } ^ { g } )$ , except that the label is a weighted average of the one-hot vector and a uniform distribution over all labels: ",
+        "bbox": [
+            174,
+            736,
+            825,
+            777
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1598271454245d13249f2fd16ea6db91cb06eaeac32118f0360e7a71a17d68ce.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\phi } - \\sum _ { j = 1 } ^ { | \\mathcal { V } | } q _ { j } \\log ( p _ { \\phi } ( \\pmb { x } ^ { g } ) _ { j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            784,
+            591,
+            830
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $q _ { j } = \\mathbb { 1 } ( j = y ) ( 1 - \\epsilon ) + \\epsilon / | y |$ and $\\epsilon$ is the smoothing weight. By forcing the classifier to be less confident on training data, label smoothing improves robustness to label noise [36] and prevents overfitting to the training set [44], thus improving generalization to different domains. ",
+        "bbox": [
+            173,
+            837,
+            825,
+            878
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The motivation for temporal ensembling is that neural networks usually first pick up easy and general patterns in the data before learning more sophisticated and dataset-specific features [83], and thus the earlier states of the network offer better generalizability to different domains. We therefore record the predictions $\\pmb { p } _ { \\phi } = p _ { \\phi } ( \\pmb { x } ^ { g } )$ of $C _ { \\phi }$ on each training sample $( \\boldsymbol { x } ^ { g } , \\boldsymbol { y } )$ at different training steps, and use the accumulated moving-average predictions $\\bar { z }$ to regularize the latest model training. This also helps suppress the fluctuation in model predictions due to data noise, offering better noise-robustness [45]. We update ensembled predictions $\\bar { z }$ once every $B$ batches: ",
+        "bbox": [
+            173,
+            883,
+            826,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            159
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/843828e40fb64f2c272f427f61a4836bc9702a01e1b43534f0465f5ed8b6aed5.jpg",
+        "text": "$$\n\\hat { z }  \\gamma \\hat { z } + ( 1 - \\gamma ) p _ { \\phi } , \\bar { z }  \\hat { z } / ( 1 - \\gamma ^ { t } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            165,
+            633,
+            184
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { z }$ has a zero initialization; $\\gamma$ is the momentum parameter; $t$ is the number of updates $\\bar { z }$ has received; the division $( 1 - \\gamma ^ { t } )$ is for bias correction [28]. We also use the ensembled prediction $\\bar { z }$ as a reliable signal to filter out noisy training samples: Only those samples on which $\\bar { z }$ strongly agrees with the label $y$ (i.e., $\\bar { z } _ { y } > \\delta$ where $\\delta > 0$ is a threshold parameter) will be used for training. ",
+        "bbox": [
+            173,
+            189,
+            825,
+            243
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We regularize model training by extending Eq. (4) to add a KL divergence regularization term from the model prediction to the ensembled prediction weighed by $\\lambda$ : ",
+        "bbox": [
+            174,
+            248,
+            823,
+            276
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4e7b74d4e911dcd50a85910c6bafa58547d53b71a643e95a7bbd077f4bf12a0.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\phi } - \\sum _ { j = 1 } ^ { | \\mathcal { V } | } q _ { j } \\log ( p _ { \\phi } ( \\pmb { x } ^ { g } ) _ { j } ) - \\lambda \\sum _ { j = 1 } ^ { | \\mathcal { V } | } \\bar { z } _ { j } \\log \\frac { p _ { \\phi } ( \\pmb { x } ^ { g } ) _ { j } } { \\bar { z } _ { j } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            284,
+            673,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We follow [28] to slowly ramp-up $\\lambda$ during training. ",
+        "bbox": [
+            174,
+            335,
+            516,
+            349
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 Overall Algorithm ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            366,
+            341,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We summarize SuperGen for singlesequence NLU tasks in Algorithm 1. Solving sequence-pair problems follows the same algorithm except the pretraining corpus $\\mathcal { D }$ is needed for sampling the first sequence $\\pmb { x } ^ { s }$ . ",
+        "bbox": [
+            174,
+            391,
+            447,
+            470
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: SuperGen for Zero-Shot Learning. ",
+        "text_level": 1,
+        "bbox": [
+            460,
+            415,
+            779,
+            429
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Input: $\\mathcal { V }$ : Label space; $\\mathcal { P }$ : Label-descriptive prompts; $G _ { \\theta }$ : Unidirectional PLM; $C _ { \\phi }$ : Bidirectional PLM. ",
+        "bbox": [
+            460,
+            431,
+            803,
+            457
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experimental Setup ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            489,
+            372,
+            507
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Downstream Tasks and Metrics. We use all the tasks included in GLUE [66] except STS-B which is a regression task. Please refer to Appendix C for more details about GLUE tasks. We follow the evaluation protocol of [13]: We use F1 score as the metric for QQP and MRPC, Matthews correlation for CoLA, and accuracy for the rest of the tasks. The original development sets of these tasks are used for testing. For all reported results, we include the average and standard deviation over 5 different random seeds. ",
+        "bbox": [
+            174,
+            522,
+            446,
+            694
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Parameter: $N$ : Number of training samples per class to generate; $M ( \\gg N )$ : Number of total training samples to generate; $T$ : Number of training steps; $B$ : Ensemble prediction update interval; $\\delta$ : Threshold parameter.   \nOutput: $C _ { \\phi } ^ { * }$ : Classifier that classifies input texts into $\\mathcal { V }$ .   \nfor $y \\in \\mathcal { V }$ do $\\overline { { \\mathcal { T } _ { y } } } \\gets \\{ \\}$ Class $_ y$ train set init. for $i \\in [ 1 , 2 , \\ldots , M ]$ do $\\pmb { x } ^ { g }  G _ { \\theta } ( \\pmb { w } _ { y } )$ Ty ← Ty S{(xg, y)} end   \nend   \n$\\tau  \\{ \\}$   \n// Selected train set.   \nfor $y \\in \\mathcal { V }$ do Sort $\\mathcal { T } _ { y }$ in descending order by Eq. (3) $\\tau  \\tau \\cup \\mathcal { T } _ { y } [ : N ]$   \nend   \n$\\hat { z } \\gets \\mathbf { 0 }$   \n// Ensembled prediction init.   \n$\\tau ^ { * }  \\tau$   \n// Filtered train set.   \nfor $i \\in [ 1 , 2 , \\dots , T ]$ do Fine-tune $C _ { \\phi }$ via Eq. (6) on a minibatch of $\\tau ^ { * }$ if $i \\% B = 0$ then Update $\\hat { z } , \\bar { z }$ via Eq. (5) $\\mathcal { T } ^ { * }  \\{ ( \\pmb { x } ^ { g } , y ) | \\bar { z } _ { y } > \\delta , ( \\pmb { x } ^ { g } , y ) \\in \\mathcal { T } \\}$ end   \nend   \nreturn $C _ { \\phi } ^ { * } = C _ { \\phi }$ ",
+        "bbox": [
+            459,
+            438,
+            816,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Models. Unless specified otherwise, we use CTRL (1.63B parameters) [23] as the generator $G _ { \\theta }$ and $\\mathrm { C O C O - L M _ { L a r g e } }$ (367M parameters) [40] as the classifier $C _ { \\phi }$ . We also show the results using similar-sized PLMs (GPT-2 [51]/RoBERTa [34]) as the generator/classifier in Section 5.6. ",
+        "bbox": [
+            174,
+            709,
+            446,
+            803
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fine-Tuning Settings and Hyperparameters. We note that SuperGen is compatible with any fine-tuning method; while using more sophisticated methods may grant ",
+        "bbox": [
+            173,
+            818,
+            447,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "further performance improvement, we use the basic prompt-based fine-tuning with manual templates approach for simplicity and clarity. For all tasks, we use the same templates and label words as in [13]. Under the zero-shot learning setting, it is not possible to tune hyperparameters due to the lack of validation sets. Therefore, we keep all fine-tuning hyperparameters (e.g., learning rate, batch size, training epochs, number of generated training samples, label smoothing and temporal ensembling hyperparameters) the same across all tasks. See Appendix B Table 10 for details. ",
+        "bbox": [
+            174,
+            871,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8e537fcceb5f356e117ef6b236cf3c146836bfbe7c553c552a797f90097495cb.jpg",
+        "table_caption": [
+            "Table 2: Results on seven GLUE classification tasks. We report average and standard deviation (as subscripts) performance over 5 different random seeds. †: Results from LM-BFF [13]. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>MNLI-(m/mm) (Acc.)</td><td>QQP (F1)</td><td>QNLI (Acc.)</td><td>SST-2 (Acc.)</td><td>CoLA (Matt.)</td><td>RTE (Acc.)</td><td>MRPC (F1)</td><td>AVG</td></tr><tr><td colspan=\"9\">Zero-Shot Setting: No task-specific data (neither labeled nor unlabeled).</td></tr><tr><td>Promptingt</td><td>50.80.0/51.70.0</td><td>49.70.0</td><td>50.80.0</td><td>83.60.0</td><td>2.00.0</td><td>51.30.0</td><td>61.90.0</td><td>50.1</td></tr><tr><td>SuperGen</td><td>72.30.5/73.80.5</td><td>66.1.1</td><td>73.31.9</td><td>92.80.6</td><td>32.75.5</td><td>65.31.2</td><td>82.20.5</td><td>69.4</td></tr><tr><td>- data selection</td><td>63.71.5/64.21.6</td><td>62.32.2</td><td>63.93.2</td><td>91.32.0</td><td>30.58.8</td><td>62.41.5</td><td>81.60.2</td><td>65.1</td></tr><tr><td>- label smooth</td><td>70.70.8/72.10.7</td><td>65.10.9</td><td>71.42.5</td><td>91.00.9</td><td>9.51.0</td><td>64.81.1</td><td>83.00.7</td><td>65.2</td></tr><tr><td>- temporal ensemble</td><td>62.04.6/63.64.8</td><td>63.90.3</td><td>72.42.0</td><td>92.50.9</td><td>23.57.0</td><td>63.51.0</td><td>78.82.2</td><td>65.3</td></tr><tr><td colspan=\"9\">Few-Shot Seting: Use 32 labeled samples/class (half for training and half for development).</td></tr><tr><td>Fine-tuning†</td><td>45.86.4/47.86.8</td><td>60.74.3</td><td>60.26.5</td><td>81.43.8</td><td>33.914.3</td><td>54.43.9</td><td>76.62.5</td><td>59.1</td></tr><tr><td>Manual prompt†</td><td>68.32.3/70.51.9</td><td>65.55.3</td><td>64.54.2</td><td>92.70.9</td><td>9.37.3</td><td>69.13.6</td><td>74.55.3</td><td>63.6</td></tr><tr><td>+ demonstrationt</td><td>70.71.3/72.01.2</td><td>69.81.8</td><td>69.21.9</td><td>92.60.5</td><td>18.78.8</td><td>68.72.3</td><td>77.82.0</td><td>66.9</td></tr><tr><td>Auto prompt</td><td>68.32.5/70.12.6</td><td>67.03.0</td><td>68.37.4</td><td>92.31.0</td><td>14.014.1</td><td>73.92.2</td><td>76.22.3</td><td>65.8</td></tr><tr><td>+ demonstration†</td><td>70.03.6/72.03.1</td><td>67.75.8</td><td>68.55.4</td><td>93.00.6</td><td>21.815.9</td><td>71.15.3</td><td>78.13.4</td><td>67.3</td></tr><tr><td>Fully supervisedt</td><td>89.8/89.5</td><td>81.7</td><td>93.3</td><td>95.0</td><td>62.6</td><td>80.9</td><td>91.4</td><td>84.9</td></tr></table>",
+        "bbox": [
+            174,
+            131,
+            823,
+            349
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c71944c472c76f051b48ba1a5cdaf2982dc201ee09878f0601a59bfb37bdaa57.jpg",
+        "table_caption": [
+            "Table 3: Results with different groups of prompts. CoLA does not use prompts for generation. The number of prompt groups is equal to the number of the task labels. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Prompt Group</td><td>MNLI-(m/mm)</td><td>QQP</td><td>QNLI</td><td>SST-2</td><td>RTE</td><td>MRPC</td></tr><tr><td>#0 (Original)</td><td>72.30.5/73.80.5</td><td>66.1.1</td><td>73.31.9</td><td>92.80.6</td><td>65.31.2</td><td>82.20.5</td></tr><tr><td>#1</td><td>70.71.4/72.41.2</td><td>65.51.4</td><td>71.91.7</td><td>92.20.9</td><td>64.41.6</td><td>81.90.4</td></tr><tr><td>#2</td><td>70.80.6/72.10.8</td><td>65.61.1</td><td>72.22.2</td><td>92.40.8</td><td>64.71.8</td><td>81.80.8</td></tr><tr><td>#3</td><td>70.91.4/72.21.4</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td></tr><tr><td>Mixed</td><td>72.20.7/73.40.6</td><td>66.91.5</td><td>73.01.7</td><td>92.80.9</td><td>66.31.0</td><td>81.32.0</td></tr></table>",
+        "bbox": [
+            223,
+            395,
+            771,
+            487
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            512,
+            825,
+            553
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Compared Methods and Ablations. We include the results of zero-shot prompting, standard few-shot fine-tuning and the four few-shot prompt-based fine-tuning methods proposed in [13]. We also conduct ablation studies by removing the following three techniques from SuperGen one at a time: (1) not using Eq. (3) for training data selection but randomly selecting the same amount of training data ( $\\_$ data selection); (2) not using label smoothing $\\underline { { \\underline { { \\mathbf { \\Pi } } } } }$ label smooth) but using one-hot labels; and (3) not using temporal ensembling (i.e., using Eq. (4) instead of Eq. (6) as the training objective) ( $-$ temporal ensemble). Lastly, we include the fully supervised fine-tuning results trained on the entire training sets. ",
+        "bbox": [
+            173,
+            568,
+            825,
+            674
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            693,
+            295,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Main Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            305,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We present the results of SuperGen, its ablations and compared methods in Table 2. Overall, SuperGen significantly outperforms zero-shot prompting and achieves an overall better result than all few-shot methods. Notably, SuperGen results in much smaller variance over different random seeds than few-shot approaches on most tasks—with access to more training data, fine-tuning of PLMs becomes much more stable. The ablation results demonstrate that all three strategies (i.e., quality training data selection, label smoothing and temporal ensembling) play important roles in improving and stabilizing the final performance, especially on challenging tasks like MNLI. ",
+        "bbox": [
+            174,
+            748,
+            825,
+            843
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Using Different Prompts ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            383,
+            873
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One important factor of SuperGen is the choice of label-descriptive prompts as they directly influence the quality of generated training samples. To study the impact of different prompt choices on the final model performance, we create different groups of prompts other than the original ones. We replace the prompt for one label used in Table 1 with a synonymous one and keep other prompts unchanged when forming a different prompt group (Please refer to Appendix A Table 8 for details). We also experiment with mixing the generated data by different prompt groups (mixed). The results are shown in Table 3. Overall, the model performance under different prompts is quite close, except on RTE whose test set is very small, potentially resulting in the higher variance. In this work, we manually choose simple prompts that make intuitive sense, and we leave the automatic searching of optimal prompts as future work. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/69e5c74206bf221048ac17346d9f4ccd6da2f7b8626c7e65c64dc66d8d607e07.jpg",
+        "image_caption": [
+            "Figure 2: Classifier accuracy fine-tuned on different amount of generated training data (after data selection). Dots and error bars are the average performance and the standard deviation over 5 seeds, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            581,
+            207
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/86bad6e8a307687f725a2dde6b8fe1da692480e94a43dd09f20030092b822a1f.jpg",
+        "image_caption": [
+            "Figure 3: Classifier accuracy on MNLI-m fine-tuned on the fewshot samples only vs. on the fewshot and SuperGen generated set with varying few-shot set sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            612,
+            88,
+            810,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            280,
+            825,
+            386
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Results with Different Amount of Generated Data ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            405,
+            558,
+            419
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "With training data automatically created by the generator, we can have a virtually infinite amount of training samples. We show the results of using different amount of generated data (after quality data selection) for fine-tuning the classifier $C _ { \\phi }$ in Fig. 2 on MNLI-m and SST-2. When the number of training data is small (e.g., 100), the fine-tuning variance is high, resulting in the similar instability issue with few-shot settings. With more generated data used, both average performance and training stability improve, yielding comparable results (with smaller variance) to fine-tuning using few-shot task-specific data. However, when too many generated data (e.g., 10, 000) are used, the classifier’s performance slightly drops, probably due to increased label noise—recall that the training data are selected based on the ranking score in Eq. (3), so using more data results in the inclusion of more lower-ranking texts in the training set and reduced data quality. One way to address this issue is to use a fixed selection ratio and increase the total number of generated texts to obtain a larger number of high-quality training data. However, this comes at a greater computation cost in the generation step. An important future direction is thus to develop better data selection strategies. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 Using SuperGen in Few-Shot Settings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            621,
+            473,
+            635
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present a simple extension of SuperGen to few-shot settings and show that the generated data of SuperGen may also improve the few-shot performance. When few-shot samples are available, we first fine-tune the classifier on the few-shot training set (standard prompt-based fine-tuning without regularization), and then continue fine-tuning the classifier on the generated data by SuperGen as described in Section 3.3. This allows the classifier to effectively leverage the knowledge from the few-shot training set to filter out noisy samples in the generated data, as temporal ensembling regularizes the classifier to remember the predictions learned previously and only keeps samples on which the model predictions agree with the label. We show the benefits of incorporating generated data for different few-shot sample sizes on MNLI in Fig. 3 (we use half labeled samples for classifier training and half for development): When the few-shot training and validation sets are rather small $( 3 2 - { \\bar { 6 } } 4 $ samples per label in total), fine-tuning the classifier on the SuperGen generated set further (after fine-tuning on the few-shot samples) brings notable performance improvements. However, such benefits diminish with more few-shot training samples: The generated data fail to improve the few-shot performance when there are 128 samples per label, and even worsen the classifier performance with 256 samples per label. This is probably because our synthetic data generation process is zero-shot and does not leverage any few-shot samples; the resulting generated samples may not be of high enough quality to boost the few-shot performance when there are relatively abundant annotated samples. Possible ways to use few-shot samples for generation include using them as demonstrations [5], for creating augmentations [29] and for tuning the generators. We leave the explorations of generating higher quality data by leveraging few-shot samples for future work. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/96fd0b4b94210c84b482091c9c5910b1c51b1a1babe69522e096b0d143e3b141.jpg",
+        "table_caption": [
+            "Table 4: Comparisons with using CTRL for zeroshot prompting and for knowledge distillation. †: The entire training set is used as unlabeled data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>MNLI-(m/mm)</td><td>SST-2</td></tr><tr><td>SuperGen</td><td>72.30.5/73.80.5</td><td>92.80.6</td></tr><tr><td>CTRL Prompting</td><td>38.50.0/39.20.0</td><td>72.50.0</td></tr><tr><td>Knowledge Distillt</td><td>40.80.5/41.50.6</td><td>73.60.8</td></tr></table>",
+        "bbox": [
+            171,
+            145,
+            488,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/48fd4c1cfe7011f347f6dfb3345c7ace316f38c3819113fb35c8245344898131.jpg",
+        "table_caption": [
+            "Table 5: Results with different generator/classifier PLMs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>PLMs (Ge/CΦ)</td><td>MNLI-(m/mm)</td><td>SST-2</td></tr><tr><td>CTRL/COCO-LM</td><td>72.30.5/73.80.5</td><td>92.80.6</td></tr><tr><td>CTRL/RoBERTa</td><td>69.00.8/70.60.9</td><td>93.01.5</td></tr><tr><td>GPT-2/COCO-LM</td><td>69.51.2/71.31.3</td><td>88.21.8</td></tr><tr><td>GPT-2/RoBERTa</td><td>68.30.9/69.70.7</td><td>88.60.8</td></tr></table>",
+        "bbox": [
+            504,
+            133,
+            818,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 Using Generators for Knowledge Distillation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            241,
+            521,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Apart from using unidirectional PLMs $G _ { \\theta }$ for training data generation, one could also directly apply them to unlabeled data formulated as prompts to obtain zero-shot predictions (i.e., prompting [5, 13]), which can then be used as soft labels to train the classifier $C _ { \\phi }$ . In Table 4, we show (1) the zero-shot prediction accuracy of CTRL (the best out of three different prompts, details in Appendix D) and (2) the classifier performance trained from CTRL’s predictions on the entire unlabeled training set as soft labels (i.e., knowledge distillation). Similar to the observations in previous studies [5, 70, 85], the zero-shot predictions of unidirectional PLMs are quite inaccurate and directly using them as soft labels to train classifiers does not yield good results. We hypothesize that the advantages of using unidirectional PLMs for training data generation over using them for zero-shot predictions are twofold: (1) Better flexibility in prompt formats. When unidirectional PLMs are used for zero-shot predictions, the prompts have to be designed so that the label word is the last token in the sequence to be predicted, as unidirectional PLMs cannot attend to subsequent tokens. Such constraints may result in the prompt being dissimilar to the pretraining data distribution and worsen the prediction quality of the PLMs. On the contrary, using unidirectional PLMs for generation is not subject to any prompt format constraints. (2) More direct uses of PLMs’ language modeling ability. Using unidirectional PLMs for training data generation directly leverages the PLMs’ output token probability. Applying PLMs for zero-shot prediction, however, requires an additional step to convert token predictions to label predictions (i.e., the verbalizer [56]), and such a mapping process usually necessitates manual curation and can hardly be optimal [13] especially without abundant task-specific data. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.6 Using Different PLMs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            366,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The final performance of SuperGen is relevant to the choice of PLMs as the generator/classifier. Apart from the default PLM choice, we report the results of using GPT-2XLarge (1.54B parameters) [51] as the generator and RoBERTaLarge (356M parameters) [34] as the classifier in Table 5 with everything else unchanged. When using GPT-2, we change the prompt used for SST-2 to “The film is bad/terrible/awful.” for the negative label and “The film is good/great/excellent.” for the positive label, since the original prompts used for SST-2 in Table 1 are a part of the control codes of CTRL and cannot be effectively leveraged by GPT-2. Overall, both CTRL and GPT-2 are able to generate quality training data for good fine-tuned classifier performance; CTRL consistently yields better results than GPT-2 regardless of the choice of the classifier PLM, probably because CTRL is pretrained with control codes which provide explicit guidance for generating texts of certain domains and attributes. We also observe that the generated text quality is strongly correlated to the generator’s model size—using a smaller version of GPT-2 (e.g., with 117M parameters) results in significantly less coherent texts and can hardly serve as training data. An interesting future direction is to try larger generator PLMs (e.g., GPT-3) which may create training data of better quality. ",
+        "bbox": [
+            174,
+            577,
+            825,
+            763
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.7 Case Studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            789,
+            300,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We present concrete examples of generated texts guided by prompts of different labels in Table 6. The generated sequences are not only coherent, but also pertain to the corresponding labels. For easier tasks like SST-2, the generated texts almost always correctly reflect the desired sentiment polarity specified by the prompt. For more difficult tasks like MNLI, sometimes the generated texts are not of the correct label (Appendix E Table 13 shows some negative results). The existence of such label noise motivates our use of the regularization techniques in the fine-tuning stage. In the future, it will be interesting to develop new methods to better control text generation towards the desired label. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0cfa299a4599f94d1efeaf65331341c69436b5dc6b1c41c2b11c39bbcf5a308d.jpg",
+        "table_caption": [
+            "Table 6: Example generated texts for SST-2, MNLI and QQP. Sampled sequences from pretraining corpus $( { \\pmb x } ^ { s } )$ are italicized; generated sequences $( \\pmb { x } ^ { g } )$ are underlined; prompts $( \\boldsymbol { w } ^ { y } )$ are in bold. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Task</td><td>Label</td><td>Generated Text</td></tr><tr><td rowspan=\"2\">SST-2</td><td>positive</td><td>Rating:5.0 The film is a great example of the kind of movie that you can watch over and over.</td></tr><tr><td>negative</td><td>Rating:1.0 The film was a total waste of time.I would not recommend this movie to anyone.</td></tr><tr><td rowspan=\"4\">MNLI</td><td>entailment</td><td>The construction of the station began in 2Ol6,when the opening date was estimated to mid-2020. In other words,the station was to open in 2020.</td></tr><tr><td rowspan=\"2\">neutral</td><td>Theconstruction of the station began in 2O16,when the opening date was estimated to mid-2020.</td></tr><tr><td>Furthermore,it is expected that a new bus terminal will be built at this station.</td></tr><tr><td rowspan=\"2\">contradiction</td><td>There sarumor thatTheconstructionofthe station beganin 2ol6,when theopeningdate was estimated to mid-2020. However,the truth is:The construction started in 2O17,andthe ofcialopening date was setfor March 31,2018.</td></tr><tr><td></td></tr><tr><td>QQP</td><td>equivalent not equivalent</td><td>What are the most wear resistant steels?In other words,what are the most durable steels? What are the most wear resistant steels?Furthermore,what is the best way to clean them?</td></tr></table>",
+        "bbox": [
+            174,
+            132,
+            821,
+            275
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Discussions and Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            291,
+            442,
+            309
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ethical Considerations. While PLMs have demonstrated remarkable text generation and understanding capability, they can come with potential risks or harms [2, 3, 5] such as generating misinformation [46] or amplifying harmful biases [49]. The focus of our work is on utilizing existing PLMs to generate training data for NLU tasks instead of developing new PLMs or generation methods. Therefore, our method can be used in company with any bias reduction and correction techniques [15, 37] to mitigate the risks of PLMs. ",
+        "bbox": [
+            174,
+            324,
+            825,
+            405
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations. One inherent limitation with zero-shot learning is the lack of access to task-specific samples for hyperparameter tuning, whereas the performance of neural networks is usually heavily dependent on the choice of hyperparameters even when the training algorithm and training set are fixed [48]. Also, without access to any labeled data, the generated training data quality may not be high enough to achieve good performance on challenging tasks, especially when the task distribution is significantly different from the pretraining data distribution (e.g., the “linguistically incorrect” label of CoLA requires generating sequences with grammar mistakes – a different distribution from the one used to train PLMs). A promising direction to address the above limitations is extending SuperGen to few-shot settings (e.g., the setting studied in Section 5.4) and leveraging a small amount of labeled data for generating better quality data and for hyperparameter tuning. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            558
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Conclusions. We propose SuperGen, an automatic supervision generation approach for zero-shot learning of NLU tasks. By providing label-descriptive prompts as guidance to a unidirectional PLM, training data can be automatically created for fine-tuning a bidirectional PLM. Our framework differs from previous transfer-learning-based zero-shot methods in that SuperGen does not rely on cross-task annotations and eliminates the task difference in training and inference. We show that several strategies are important for effective and stable fine-tuning on generated data, including quality training data selection, label smoothing and temporal ensembling. SuperGen achieves strong performance on seven classification tasks of the GLUE benchmark, even yielding comparable or better results than sophisticated few-shot learning methods and offering better stability. There is large room for future work, including but not limited to: Extension to few-shot learning settings, exploring larger generator models [25, 68], better fine-tuning techniques to leverage generated data and better strategies for selecting quality training data. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            758,
+            328,
+            775
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Research was supported in part by US DARPA KAIROS Program No. FA8750-19-2-1004 and INCAS Program No. HR001121C0165, National Science Foundation IIS-19-56151, IIS-17-41317, and IIS 17-04532, and the Molecule Maker Lab Institute: An AI Research Institutes program supported by NSF under Award No. 2019897, and the Institute for Geospatial Understanding through an Integrative Discovery Environment (I-GUIDE) by NSF under Award No. 2118329. Any opinions, findings, and conclusions or recommendations expressed herein are those of the authors and do not necessarily represent the views, either expressed or implied, of DARPA or the U.S. Government. Yu Meng is supported by the Google PhD Fellowship. We thank anonymous reviewers for valuable and insightful feedback. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            266,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Ateret Anaby-Tavor, Boaz Carmeli, Esther Goldbraich, Amir Kantor, George Kour, Segev Shlomov, Naama Tepper, and Naama Zwerdling. Do not have enough data? deep learning to the rescue! In AAAI, 2020.   \n[2] Emily M. Bender and Alexander Koller. Climbing towards NLU: On meaning, form, and understanding in the age of data. In ACL, 2020.   \n[3] Emily M. Bender, Timnit Gebru, Angelina McMillan-Major, and Shmargaret Shmitchell. On the dangers of stochastic parrots: Can language models be too big? In ACM Conference on Fairness, Accountability, and Transparency, 2021.   \n[4] Luisa Bentivogli, Peter Clark, Ido Dagan, and Danilo Giampiccolo. The fifth pascal recognizing textual entailment challenge. In TAC, 2009.   \n[5] Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. In NeurIPS, 2020.   \n[6] Alvin Chan, Y. Ong, Bill Tuck Weng Pung, Aston Zhang, and Jie Fu. CoCon: A self-supervised approach for controlled text generation. In ICLR, 2021.   \n[7] Jiaao Chen, Zichao Yang, and Diyi Yang. Mixtext: Linguistically-informed interpolation of hidden space for semi-supervised text classification. In ACL, 2020.   \n[8] Kevin Clark, Minh-Thang Luong, Quoc V Le, and Christopher D Manning. ELECTRA: Pre-training text encoders as discriminators rather than generators. In ICLR, 2020.   \n[9] Ido Dagan, Oren Glickman, and Bernardo Magnini. The pascal recognising textual entailment challenge. In Machine Learning Challenges Workshop, 2005.   \n[10] Sumanth Dathathri, Andrea Madotto, Janice Lan, Jane Hung, Eric Frank, Piero Molino, Jason Yosinski, and Rosanne Liu. Plug and play language models: A simple approach to controlled text generation. In ICLR, 2020.   \n[11] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In NAACL-HLT, 2019.   \n[12] William B Dolan and Chris Brockett. Automatically constructing a corpus of sentential paraphrases. In International Workshop on Paraphrasing (IWP), 2005.   \n[13] Tianyu Gao, Adam Fisch, and Danqi Chen. Making pre-trained language models better few-shot learners. In ACL, 2021.   \n[14] Tianyu Gao, Xingcheng Yao, and Danqi Chen. SimCSE: Simple contrastive learning of sentence embeddings. In EMNLP, 2021.   \n[15] Samuel Gehman, Suchin Gururangan, Maarten Sap, Yejin Choi, and Noah A. Smith. RealToxicityPrompts: Evaluating neural toxic degeneration in language models. In Findings of EMNLP, 2020.   \n[16] Danilo Giampiccolo, Bernardo Magnini, Ido Dagan, and Bill Dolan. The third pascal recognizing textual entailment challenge. In ACL-PASCAL workshop on textual entailment and paraphrasing, 2007.   \n[17] Aaron Gokaslan and Vanya Cohen. OpenWebText corpus. http://Skylion007.github. io/OpenWebTextCorpus, 2019.   \n[18] R Bar Haim, Ido Dagan, Bill Dolan, Lisa Ferro, Danilo Giampiccolo, Bernardo Magnini, and Idan Szpektor. The second pascal recognising textual entailment challenge. In PASCAL Challenges Workshop on Recognising Textual Entailment, 2006.   \n[19] Pengcheng He, Xiaodong Liu, Jianfeng Gao, and Weizhu Chen. DeBERTa: Decoding-enhanced BERT with disentangled attention. In ICLR, 2021.   \n[20] Geoffrey E. Hinton, Oriol Vinyals, and Jeffrey Dean. Distilling the knowledge in a neural network. ArXiv, abs/1503.02531, 2015.   \n[21] Ari Holtzman, Jan Buys, Maxwell Forbes, and Yejin Choi. The curious case of neural text degeneration. In ICLR, 2020.   \n[22] Zhiting Hu, Zichao Yang, Xiaodan Liang, Ruslan Salakhutdinov, and Eric P. Xing. Toward controlled generation of text. In ICML, 2017.   \n[23] Nitish Shirish Keskar, Bryan McCann, Lav R. Varshney, Caiming Xiong, and Richard Socher. CTRL: A conditional transformer language model for controllable generation. ArXiv, abs/1909.05858, 2019.   \n[24] Muhammad Khalifa, Hady ElSahar, and Marc Dymetman. A distributional approach to controlled text generation. In ICLR, 2021.   \n[25] Boseop Kim, HyoungSeok Kim, Sang-Woo Lee, Gichang Lee, Donghyun Kwak, Dong Hyeon Jeon, Sunghyun Park, Sungju Kim, Seonhoon Kim, Dongpil Seo, et al. What changes can largescale language models bring? intensive study on hyperclova: Billions-scale korean generative pretrained transformers. In EMNLP, 2021.   \n[26] Ben Krause, Akhilesh Deepak Gotmare, Bryan McCann, Nitish Shirish Keskar, Shafiq R. Joty, Richard Socher, and Nazneen Rajani. GeDi: Generative discriminator guided sequence generation. In EMNLP, 2021.   \n[27] Sachin Kumar, Eric Malmi, Aliaksei Severyn, and Yulia Tsvetkov. Controlled text generation as continuous optimization with multiple constraints. In NeurIPS, 2021.   \n[28] Samuli Laine and Timo Aila. Temporal ensembling for semi-supervised learning. In ICLR, 2017.   \n[29] Kenton Lee, Kelvin Guu, Luheng He, Tim Dozat, and Hyung Won Chung. Neural data augmentation via example extrapolation. arXiv preprint arXiv:2102.01335, 2021.   \n[30] Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Veselin Stoyanov, and Luke Zettlemoyer. BART: Denoising sequence-to-sequence pre-training for natural language generation, translation, and comprehension. In ACL, 2020.   \n[31] Xiang Lisa Li and Percy Liang. Prefix-tuning: Optimizing continuous prompts for generation. In ACL, 2021.   \n[32] Alisa Liu, Maarten Sap, Ximing Lu, Swabha Swayamdipta, Chandra Bhagavatula, Noah A. Smith, and Yejin Choi. DExperts: Decoding-time controlled text generation with experts and anti-experts. In ACL, 2021.   \n[33] Xiao Liu, Yanan Zheng, Zhengxiao Du, Ming Ding, Yujie Qian, Zhilin Yang, and Jie Tang. GPT understands, too. ArXiv, abs/2103.10385, 2021.   \n[34] Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. RoBERTa: A robustly optimized BERT pretraining approach. arXiv preprint arXiv:1907.11692, 2019.   \n[35] Robert L Logan IV, Ivana Balazevi ˇ c, Eric Wallace, Fabio Petroni, Sameer Singh, and Sebastian ´ Riedel. Cutting down on prompts and parameters: Simple few-shot learning with language models. arXiv preprint arXiv:2106.13353, 2021.   \n[36] Michal Lukasik, Srinadh Bhojanapalli, Aditya Krishna Menon, and Surinder Kumar. Does label smoothing mitigate label noise? In ICML, 2020.   \n[37] Xinyao Ma, Maarten Sap, Hannah Rashkin, and Yejin Choi. PowerTransformer: Unsupervised controllable revision for biased language correction. In EMNLP, 2020.   \n[38] Yu Meng, Jiaming Shen, Chao Zhang, and Jiawei Han. Weakly-supervised neural text classification. In CIKM, 2018.   \n[39] Yu Meng, Jiaming Shen, Chao Zhang, and Jiawei Han. Weakly-supervised hierarchical text classification. In AAAI, 2019.   \n[40] Yu Meng, Chenyan Xiong, Payal Bajaj, Saurabh Tiwary, Paul Bennett, Jiawei Han, and Xia Song. COCO-LM: Correcting and contrasting text sequences for language model pretraining. In NeurIPS, 2021.   \n[41] Yu Meng, Chenyan Xiong, Payal Bajaj, Saurabh Tiwary, Paul Bennett, Jiawei Han, and Xia Song. Pretraining text encoders with adversarial mixture of training signal generators. In ICLR, 2022.   \n[42] Swaroop Mishra, Daniel Khashabi, Chitta Baral, and Hannaneh Hajishirzi. Cross-task generalization via natural language crowdsourcing instructions. arXiv preprint arXiv:2104.08773, 2021.   \n[43] Takeru Miyato, Andrew M. Dai, and Ian J. Goodfellow. Adversarial training methods for semi-supervised text classification. In ICLR, 2017.   \n[44] Rafael Muller, Simon Kornblith, and Geoffrey E. Hinton. When does label smoothing help? In ¨ NeurIPS, 2019.   \n[45] Duc Tam Nguyen, Chaithanya Kumar Mummadi, Thi-Phuong-Nhung Ngo, Thi Hoai Phuong Nguyen, Laura Beggel, and Thomas Brox. SELF: Learning to filter noisy labels with selfensembling. In ICLR, 2020.   \n[46] Artidoro Pagnoni, Vidhisha Balachandran, and Yulia Tsvetkov. Understanding factuality in abstractive summarization with FRANK: A benchmark for factuality metrics. In NAACL, 2021.   \n[47] Damian Pascual, Beni Egressy, Clara Meister, Ryan Cotterell, and Roger Wattenhofer. A ´ plug-and-play method for controlled text generation. In Findings of EMNLP, 2021.   \n[48] Ethan Perez, Douwe Kiela, and Kyunghyun Cho. True few-shot learning with language models. In NeurIPS, 2021.   \n[49] Shrimai Prabhumoye, Yulia Tsvetkov, Ruslan Salakhutdinov, and Alan W. Black. Style transfer through back-translation. In ACL, 2018.   \n[50] Raul Puri and Bryan Catanzaro. Zero-shot text classification with generative language models. ArXiv, abs/1912.10165, 2019.   \n[51] Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. OpenAI blog, 1(8):9, 2019.   \n[52] 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, 2019.   \n[53] Nils Reimers and Iryna Gurevych. Sentence-BERT: Sentence embeddings using siamese BERT-networks. In EMNLP, 2019.   \n[54] Victor Sanh, Albert Webson, Colin Raffel, Stephen H Bach, Lintang Sutawika, Zaid Alyafeai, Antoine Chaffin, Arnaud Stiegler, Teven Le Scao, Arun Raja, et al. Multitask prompted training enables zero-shot task generalization. In ICLR, 2022.   \n[55] Teven Le Scao and Alexander M. Rush. How many data points is a prompt worth? In NAACL, 2021.   \n[56] Timo Schick and Hinrich Schutze. Exploiting cloze-questions for few-shot text classification ¨ and natural language inference. In EACL, 2021.   \n[57] Timo Schick and Hinrich Schutze. Few-shot text generation with natural language instructions. ¨ In EMNLP, 2021.   \n[58] Timo Schick and Hinrich Schutze. Generating datasets with pretrained language models. In ¨ EMNLP, 2021.   \n[59] Timo Schick and Hinrich Schutze. It’s not just size that matters: Small language models are ¨ also few-shot learners. In NAACL, 2021.   \n[60] Iyer Shankar, Dandekar Nikhil, and Csernai Kornel.´ First Quora dataset release: Question pairs, 2017. URL https://www.quora.com/q/quoradata/ First-Quora-Dataset-Release-Question-Pairs.   \n[61] Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew Y $\\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In EMNLP, 2013.   \n[62] Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.   \n[63] Derek Tam, Rakesh R Menon, Mohit Bansal, Shashank Srivastava, and Colin Raffel. Improving and simplifying pattern exploiting training. In EMNLP, 2021.   \n[64] Lisa Torrey and Jude Shavlik. Transfer learning. In Handbook of research on machine learning applications and trends: algorithms, methods, and techniques. 2010.   \n[65] 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.   \n[66] Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In EMNLP Workshop BlackboxNLP, 2018.   \n[67] Alex Wang, Yada Pruksachatkun, Nikita Nangia, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. SuperGLUE: A stickier benchmark for general-purpose language understanding systems. In NeurIPS, 2019.   \n[68] Zirui Wang, Adams Wei Yu, Orhan Firat, and Yuan Cao. Towards zero-label language learning. arXiv preprint arXiv:2109.09193, 2021.   \n[69] Alex Warstadt, Amanpreet Singh, and Samuel R Bowman. Neural network acceptability judgments. In TACL, 2019.   \n[70] Jason Wei, Maarten Bosma, Vincent Zhao, Kelvin Guu, Adams Wei Yu, Brian Lester, Nan Du, Andrew M. Dai, and Quoc V. Le. Finetuned language models are zero-shot learners. In ICLR, 2022.   \n[71] Sean Welleck, Ilia Kulikov, Stephen Roller, Emily Dinan, Kyunghyun Cho, and Jason Weston. Neural text generation with unlikelihood training. In ICLR, 2020.   \n[72] Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In NAACL-HLT, 2018.   \n[73] Qizhe Xie, Zihang Dai, Eduard H. Hovy, Minh-Thang Luong, and Quoc V. Le. Unsupervised data augmentation for consistency training. In NeurIPS, 2020.   \n[74] Hanwei Xu, Yujun Chen, Yulun Du, Nan Shao, Yanggang Wang, Haiyu Li, and Zhilin Yang. ZeroPrompt: Scaling prompt-based pretraining to 1, 000 tasks improves zero-shot generalization. ArXiv, abs/2201.06910, 2022.   \n[75] Kevin Yang and Dan Klein. FUDGE: Controlled text generation with future discriminators. In NAACL, 2021.   \n[76] Yiben Yang, Chaitanya Malaviya, Jared Fernandez, Swabha Swayamdipta, Ronan Le Bras, Ji Ping Wang, Chandra Bhagavatula, Yejin Choi, and Doug Downey. Generative data augmentation for commonsense reasoning. In Findings of EMNLP, 2020.   \n[77] Jiacheng Ye, Jiahui Gao, Qintong Li, Hang Xu, Jiangtao Feng, Zhiyong Wu, Tao Yu, and Lingpeng Kong. ZeroGen: Efficient zero-shot learning via dataset generation. ArXiv, abs/2202.07922, 2022.   \n[78] Qinyuan Ye, Bill Yuchen Lin, and Xiang Ren. Crossfit: A few-shot learning challenge for cross-task generalization in nlp. In EMNLP, 2021.   \n[79] Wenpeng Yin, Jamaal Hay, and Dan Roth. Benchmarking zero-shot text classification: Datasets, evaluation and entailment approach. In EMNLP, 2019.   \n[80] Wenpeng Yin, Nazneen Rajani, Dragomir Radev, Richard Socher, and Caiming Xiong. Universal natural language processing with limited annotations: Try few-shot textual entailment as a start. In EMNLP, 2020.   \n[81] Kang Min Yoo, Dongju Park, Jaewook Kang, Sang-Woo Lee, and Woomyeong Park. GPT3Mix: Leveraging large-scale language models for text augmentation. In EMNLP Findings, 2021.   \n[82] Weizhe Yuan, Graham Neubig, and Pengfei Liu. BARTScore: Evaluating generated text as text generation. In NeurIPS, 2021.   \n[83] Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. In ICLR, 2017.   \n[84] Ningyu Zhang, Luoqiu Li, Xiang Chen, Shumin Deng, Zhen Bi, Chuanqi Tan, Fei Huang, and Huajun Chen. Differentiable prompt makes pre-trained language models better few-shot learners. In ICLR, 2022.   \n[85] Tony Zhao, Eric Wallace, Shi Feng, Dan Klein, and Sameer Singh. Calibrate before use: Improving few-shot performance of language models. In ICML, 2021.   \n[86] Ruiqi Zhong, Kristy Lee, Zheng Zhang, and Dan Klein. Adapting language models for zero-shot learning by meta-tuning on dataset and prompt collections. In Findings of EMNLP, 2021.   \n[87] Fuzhen Zhuang, Zhiyuan Qi, Keyu Duan, Dongbo Xi, Yongchun Zhu, Hengshu Zhu, Hui Xiong, and Qing He. A comprehensive survey on transfer learning. Proceedings of the IEEE, 2020.   \n[88] Daniel M. Ziegler, Nisan Stiennon, Jeff Wu, Tom B. Brown, Alec Radford, Dario Amodei, Paul Christiano, and Geoffrey Irving. Fine-tuning language models from human preferences. ArXiv, abs/1909.08593, 2019. ",
+        "bbox": [
+            171,
+            97,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            49,
+            828,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            828,
+            917
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            68,
+            828,
+            919
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            828,
+            454
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            478,
+            254,
+            494
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            505,
+            339,
+            518
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            523,
+            825,
+            612
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            616,
+            493,
+            630
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            633,
+            738,
+            664
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            667,
+            393,
+            683
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            685,
+            825,
+            801
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            805,
+            823,
+            819
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [Yes]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A] ",
+        "bbox": [
+            238,
+            823,
+            825,
+            912
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            215,
+            122,
+            705,
+            137
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            141,
+            826,
+            228
+        ],
+        "page_idx": 15
+    }
+]

parse/dev/NjeEfP7e3KZ/NjeEfP7e3KZ_content_list.json

@@ -0,0 +1,1343 @@
+[
+    {
+        "type": "text",
+        "text": "Revisiting Heterophily For Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            186,
+            122,
+            812,
+            148
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sitao Luan1,2, Chenqing $\\mathbf { H u a } ^ { 1 , 2 }$ , Qincheng ${ { \\bf L } } { \\bf u } ^ { 1 }$ , Jiaqi $\\mathbf { Z } \\mathbf { h } \\mathbf { u } ^ { 1 }$ , Mingde Zhao1,2, Shuyuan Zhang1,2, Xiao-Wen Chang1, Doina Precup1,2,3 {sitao.luan $@$ mail, chenqing.hua $@$ mail, qincheng.lu $@$ mail, jiaqi.zhu $@$ mail, mingde.zhao $@$ mail, shuyuan.zhang $@$ mail, chang@cs, dprecup@cs}.mcgill.ca 1McGill University; 2Mila; 3DeepMind ",
+        "bbox": [
+            186,
+            199,
+            862,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            296,
+            535,
+            313
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs) extend basic Neural Networks (NNs) by using graph structures based on the relational inductive bias (homophily assumption). While GNNs have been commonly believed to outperform NNs in real-world tasks, recent work has identified a non-trivial set of datasets where their performance compared to NNs is not satisfactory. Heterophily has been considered as the main cause of this empirical observation and numerous works have been put forward to address it. In this paper, we first revisit the widely used homophily metrics and point out that their consideration of only graph-label consistency is a shortcoming. Then, we study heterophily from the perspective of post-aggregation node similarity and define new homophily metrics, which are verified to be advantageous compared to existing ones. Based on this investigation, we prove that some harmful cases of heterophily can be effectively addressed by local diversification operation. Then, we propose the Adaptive Channel Mixing (ACM), a framework to adaptively exploit aggregation, diversification and identity channels node-wisely to extract richer localized information for diverse node heterophily situations. ACM is more powerful than the commonly used uni-channel framework for node classification tasks on heterophilic graphs and is easy to be implemented in baseline GNN layers. When evaluated on 10 benchmark node classification tasks, ACM-augmented baselines consistently achieve significant performance gain, exceeding state-of-theart GNNs on most tasks without incurring significant computational burden. Code: https://github.com/SitaoLuan/ACM-GNN ",
+        "bbox": [
+            232,
+            328,
+            766,
+            618
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            638,
+            312,
+            655
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep Neural Networks (NNs) $\\pmb { \\mathbb { Z } } 2 \\mathbf { l }$ have revolutionized many machine learning areas, including image recognition $\\scriptstyle { \\left[ \\left[ 2 1 \\right] \\right] }$ , speech recognition $\\mathbb { \\lVert 1 3 \\rVert }$ and natural language processing $\\left[ \\left[ 2 \\right] \\right]$ , due to their effectiveness in learning latent representations from Euclidean data. Recent research has shifted focus on non-Euclidean data $\\boxed { 6 }$ , e.g., relational data or graphs. Combining graph signal processing and convolutional neural networks $\\pmb {  \\pmb {  \\pmb {  \\frac { \\ d H } { \\ d H }  }  } }$ , numerous Graph Neural Network (GNN) architectures have been proposed [39, 10, 15, 41, 19, 30], which empirically outperform traditional NNs on graph-based machine learning tasks such as node classification, graph classification, link prediction and graph generation, etc.GNNs are built on the homophily assumption $\\pmb { \\Vert 3 5 \\Vert }$ : connected nodes tend to share similar attributes with each other $\\pmb { \\mathbb { I } } \\pmb { \\mathbb { 1 } }$ , which offers additional information besides node features. This relational inductive bias $\\pmb { \\mathbb { B } } \\|$ is believed to be a key factor leading to GNNs’ superior performance over NNs’ in many tasks. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            810
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, growing empirical evidence suggests that GNNs are not always advantageous compared to traditional NNs. In some cases, even simple Multi-Layer Perceptrons (MLPs) can outperform GNNs by a large margin on relational data [46, 29, 32, 8]. An important reason for this is believed to be the heterophily problem: the homophily assumption does not always hold, so connected nodes may in fact have different attributes. Heterophily has received lots of attention recently and an increasing number of models have been put forward to address this problem [46, 29, 32, 8, 45, 44, 33, 16, 24]. In this paper, we first show that by only considering graph-label consistency, existing homophily metrics are not able to describe the effect of some cases of heterophily on aggregation-based GNNs. We propose a post-aggregation node similarity matrix, and based on it, we derive new homophily metrics, whose advantages are illustrated on synthetic graphs (Sec. 3). Then, we prove that diversification operation can help to address some harmful cases of heterophily (Sec. 4). Based on this, we propose the Adaptive Channel Mixing (ACM) GNN framework which augments uni-channel baseline GNNs, allowing them to exploit aggregation, diversification and identity channels adaptively, node-wisely and locally in each layer. ACM significantly boosts the performance of 3 uni-channel baseline GNNs by $2 . 0 4 \\% \\sim 2 7 . 5 \\%$ for node classification tasks on 7 widely used benchmark heterophilic graphs, exceeding SOTA models $\\left( \\mathsf { S e c . } \\bigtriangledown \\right)$ on all of them. For 3 homophilic graphs, ACM-augmented GNNs can perform at least as well as the uni-channel baselines and are competitive compared with SOTA. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            826,
+            243
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions 1. To our knowledge, we are the first to analyze heterophily from post-aggregation node similarity perspective. 2. The proposed ACM framework is highly different from adaptive filterbank with multiple channels and existing GNNs for heterophily: 1) the traditional adaptive filterbank channels $\\dot { \\left[ \\left| 4 0 \\right| \\right] }$ uses a scalar weight for each filter and this weight is shared by all nodes. In contrast, ACM provides a mechanism so that different nodes can learn different weights to utilize information from different channels to account for diverse local heterophily; 2) Unlike existing methods that leverage the high-order filters and global property of high-frequency signals [46, 29, 8, 16] which require more computational resources, ACM successfully addresses heterophily by considering only the nodewise local information adaptively. 3. Unlike existing methods that try to facilitate learning filters with high expressive power [46, 45, 8, 16], ACM aims that, when given a filter with certain expressive power, we can extract richer information from additional channels in a certain way to address heterophily. This makes ACM more flexible and easier to be implemented. ",
+        "bbox": [
+            173,
+            247,
+            826,
+            414
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            422,
+            318,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce notation and background knowledge. We use bold font for vectors $( e . g . , v )$ . Suppose we have an undirected connected graph $\\mathcal { G } = ( \\mathcal { V } , \\mathcal { E } , A )$ , where $\\nu$ is the node set with $| \\nu | = N$ ; $\\mathcal { E }$ is the edge set without self-loops; $\\bar { A } \\in \\mathbf { \\mathbb { R } } ^ { N \\times N }$ is the symmetric adjacency matrix with $A _ { i , j } = 1$ if $e _ { i j } \\in \\mathcal { E }$ , otherwise $A _ { i , j } = 0$ . Let $D$ denote the diagonal degree matrix of $\\mathcal { G }$ , i.e., $\\begin{array} { r } { D _ { i , i } = \\bar { d } _ { i } = \\sum _ { j } \\bar { A _ { i , j } } } \\end{array}$ . Let ${ \\mathcal { N } } _ { i }$ denote the neighborhood set of node $i$ , i.e., $\\tilde { \\mathcal { N } _ { i } } = \\{ j : e _ { i j } \\in \\mathcal { E } \\}$ . A graph signal is a vector $\\pmb { x } \\in \\mathbb { R } ^ { N }$ defined on $\\nu$ , where $\\mathbf { \\Delta } _ { \\mathbf { \\mathcal { X } } _ { i } }$ is associated with node $i$ . We also have a feature matrix $X \\in \\mathbb { R } ^ { N \\times F }$ 2 V , whose columns are graph signals and whose $i$ -th row $X _ { i , \\astrosun }$ : is a feature vector of node $i$ . We use $Z \\in \\mathbb { R } ^ { N \\times C }$ to denote the label encoding matrix, whose $i$ -th row $Z _ { i , : }$ : is the one-hot encoding of the label of node $i$ . ",
+        "bbox": [
+            173,
+            443,
+            826,
+            573
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Graph Laplacian, Affinity Matrix and Variants ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            588,
+            540,
+            604
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The (combinatorial) graph Laplacian is defined as $L = D - A$ , which is Symmetric Positive Semi-Definite (SPSD) $\\bar { \\bigtriangledown } |$ . Its eigendecomposition is ${ \\cal L } \\ : = \\ : U \\Lambda U ^ { T }$ , where the columns $\\mathbf { \\Delta } \\mathbf { u } _ { i }$ of $U \\in \\mathbb { R } ^ { N \\times N }$ are orthonormal eigenvectors, namely the graph Fourier basis, $\\boldsymbol { \\Lambda } = \\operatorname { d i a g } ( \\lambda _ { 1 } , \\ldots , \\lambda _ { N } )$ with $\\lambda _ { 1 } \\leq \\cdots \\leq \\lambda _ { N }$ . These eigenvalues are also called frequencies. ",
+        "bbox": [
+            173,
+            611,
+            826,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In additional to $L$ , some variants are also commonly used, e.g., the symmetric normalized Laplacian $L _ { \\mathrm { s v m } } = D ^ { - 1 / 2 } L D ^ { - 1 / 2 } = I - D ^ { - 1 / 2 } A D ^ { - 1 / 2 }$ and the random walk normalized Laplacian $L _ { \\mathrm { r w } } =$ $D ^ { \\dot { - } 1 } L = I - D ^ { - 1 } A$ . The graph Laplacian and its variants can be considered as high-pass filters for graph signals. The affinity (transition) matrices can be derived from the Laplacians, e.g., $A _ { \\mathrm { r w } } =$ $I - L _ { \\mathrm { r w } } = D ^ { - 1 } A$ , $A _ { \\mathrm { s y m } } = \\bar { I } - L _ { \\mathrm { s y m } } = D ^ { - 1 / 2 } A D ^ { - 1 / 2 }$ and are considered to be low-pass filters $\\textcircled { 1 3 4 } \\textcircled { 1 }$ . Their eigenvalues satisfy $\\lambda _ { i } ( A _ { \\mathrm { r w } } ) = \\lambda _ { i } ( A _ { \\mathrm { s y m } } ) = 1 - \\lambda _ { i } ( L _ { \\mathrm { s y m } } ) = 1 - \\lambda _ { i } ( L _ { \\mathrm { r w } } ) { \\it \\bar { \\Psi } } \\in ( - 1 , 1 ]$ Applying the renormalization trick $\\mathbb { 1 1 9 }$ to affinity and Laplacian matrices respectively leads to $\\hat { A } _ { \\mathrm { s y m } } ^ { - 1 } = \\bar { \\tilde { D } } ^ { - 1 / 2 } \\tilde { A } \\tilde { D } ^ { - 1 / 2 }$ and $\\hat { L } _ { \\mathrm { s y m } } = I - \\hat { A } _ { \\mathrm { s y m } }$ , where ${ \\tilde { A } } \\equiv A + I$ and $\\tilde { D } \\equiv D + I$ . The renormalized affinity matrix essentially adds a self-loop to each node in the graph, and is widely used in Graph Convolutional Network (GCN) $\\mathbb { \\lVert 1 9 \\rVert }$ as follows: ",
+        "bbox": [
+            173,
+            672,
+            825,
+            818
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d06cc46772e54342a924e451a178ab0a15315fc5f732dde7035119f42d0d33ac.jpg",
+        "text": "$$\nY = \\mathrm { s o f t m a x } ( { \\hat { A } } _ { \\mathrm { s y m } } \\mathrm { R e L U } ( { \\hat { A } } _ { \\mathrm { s y m } } X W _ { 0 } ) W _ { 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            824,
+            643,
+            844
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { 0 } \\in \\mathbb { R } ^ { F \\times F _ { 1 } }$ and $W _ { 1 } \\in \\mathbb { R } ^ { F _ { 1 } \\times O }$ are learnable parameter matrices. GCNs can be trained by minimizing the following cross entropy loss ",
+        "bbox": [
+            171,
+            851,
+            823,
+            881
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6c68fa7091c1e02328c7c1fcb9640a37d299cb062ee067c5da320bb5fc53aa9e.jpg",
+        "text": "$$\n\\mathcal { L } = - \\mathrm { t r a c e } ( Z ^ { T } \\log Y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            893,
+            578,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\log ( \\cdot )$ is a component-wise logarithm operation. The random walk renormalized matrix $\\hat { A } _ { \\mathrm { r w } } = \\tilde { D } ^ { - 1 } \\tilde { A }$ , which shares the same eigenvalues as $\\hat { A } _ { \\mathrm { s y m } }$ , can also be applied in GCN. The corresponding Laplacian is defined as $\\hat { L } _ { \\mathrm { r w } } = I - \\hat { A } _ { \\mathrm { r w } }$ . The matrix $\\hat { A } _ { \\mathrm { r w } }$ is essentially a random walk matrix and behaves as a mean aggregator that is applied in spatial-based GNNs [15, 14]. To bridge spectral and spatial methods, we use $\\hat { A } _ { r w }$ in this paper. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            170
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Metrics of Homophily ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            184,
+            366,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The homophily metrics are defined by considering different relations between node labels and graph structures. There are three commonly used homophily metrics: edge homophily [1, $\\boxed { 4 6 }$ , node homophily $\\pmb { \\mathbb { B } } 6 \\|$ and class homophily $\\underline { { \\| \\mathbf { \\check { 2 } 6 } \\| } } \\big \\|$ , defined as follows: ",
+        "bbox": [
+            174,
+            205,
+            826,
+            248
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/84b6f85bf06d286693cd2739aefbe75a178f41b0a68ee5b062e574059a80b07f.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { I } _ { \\mathrm { c d g c } } ( \\boldsymbol { \\mathcal { G } } ) = \\frac { \\big | \\{ e _ { u v } \\mid e _ { u v } \\in \\mathcal { E } , Z _ { u , : } = Z _ { v , : } \\} \\big | } { | \\mathcal { E } | } , H _ { \\mathrm { n o d c } } ( \\boldsymbol { \\mathcal { G } } ) = \\frac { 1 } { | \\mathcal { V } | } \\displaystyle \\sum _ { v \\in \\mathcal { V } } H _ { \\mathrm { n o d e } } ^ { v } = \\frac { 1 } { | \\mathcal { V } | } \\displaystyle \\sum _ { v \\in \\mathcal { V } } \\frac { \\big | \\{ u \\mid u \\in \\mathcal { N } _ { v } , Z _ { u , : } = Z _ { v , : } \\} \\big | } { d _ { v } } \\mathrm { ~ , ~ } } \\\\ { \\displaystyle \\mathcal { I } _ { \\mathrm { c l a s s } } ( \\boldsymbol { \\mathcal { G } } ) = \\frac { 1 } { C - 1 } \\displaystyle \\sum _ { k = 1 } ^ { C } \\Big [ h _ { k } - \\frac { \\big | \\{ v \\mid Z _ { v , k } = 1 \\} \\big | } { N } \\Big ] _ { + } , h _ { k } = \\frac { \\sum _ { v \\in \\mathcal { V } } \\big | \\{ u \\mid Z _ { v , k } = 1 , u \\in \\mathcal { N } _ { v } , Z _ { u , : } = Z _ { v , : } \\} \\big | } { \\sum _ { v \\in \\{ v \\mid Z _ { v , k } = 1 \\} } d _ { v } } \\mathrm { ~ . ~ } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            250,
+            839,
+            338
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $H _ { \\mathrm { n o d e } } ^ { v }$ is the local homophily value for node $v$ ; $[ a ] _ { + } = \\operatorname* { m a x } ( a , 0 )$ ; $h _ { k }$ is the class-wise homophily metric $\\left\\| 2 6 \\right\\|$ . All metrics are in the range of $[ 0 , 1 ]$ ; a value close to $1$ corresponds to strong homophily, while a value close to 0 indicates strong heterophily. $H _ { \\mathrm { e d g e } } ( { \\mathcal { G } } )$ measures the proportion of edges that connect two nodes in the same class; $H _ { \\mathrm { n o d e } } ( \\mathcal { G } )$ evaluates the average proportion of edge-label consistency of all nodes; $H _ { \\mathrm { c l a s s } } ( \\mathcal { G } )$ tries to avoid sensitivity to imbalanced classes, which can make $H _ { \\mathrm { e d g e } } ( { \\mathcal { G } } )$ misleadingly large. The above definitions are all based on the linear featureindependent graph-label consistency. The inconsistency relation is implied to have a negative effect to the performance of GNNs. With this in mind, in the following section, we give an example to illustrate the shortcomings of the above metrics and propose new feature-independent metrics that are defined from post-aggregation node similarity perspective, which is novel. ",
+        "bbox": [
+            173,
+            347,
+            826,
+            487
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Analysis of Heterophily ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            493,
+            401,
+            511
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Motivation and Aggregation Homophily ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            491,
+            532
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Heterophily is widely believed to be harmful for message-passing based GNNs [46, 36, 8] because, intuitively, features of nodes in different classes will be falsely mixed, leading nodes to be indistinguishable $| \\overline { { \\mathbb { H } 6 } } |$ . Nevertheless, it is not always the case, e.g., the bipartite graph2 shown in Figure $\\nsupseteq$ is highly heterophilic according to the existing homophily metrics in equation $\\textcircled { 3 }$ but after mean aggregation, the nodes in classes 1 and 2 just exchange colors and are still distinguishable3. This example tells us that, besides graph-label consistency, we need to study the relation between nodes after aggregation step. ",
+        "bbox": [
+            174,
+            539,
+            485,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c1b018a040bcfe67973ad8ddb5a86b14d4e381ebf8420d541eb78816666b447f.jpg",
+        "image_caption": [
+            "Figure 1: Example of harmless heterophily "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            561,
+            818,
+            665
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To this end, we first define the post-aggregation node similarity matrix as follows: ",
+        "bbox": [
+            174,
+            719,
+            709,
+            733
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11b04dfec0cf0e06df547897cefe9b381486344cb2b47b41d1c8217936ef6ddd.jpg",
+        "text": "$$\nS ( \\hat { A } , X ) \\equiv \\hat { A } X ( \\hat { A } X ) ^ { T } \\in \\mathbb { R } ^ { N \\times N }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            736,
+            612,
+            755
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { A } \\in \\mathbb { R } ^ { N \\times N }$ denotes a general aggregation operator. $S ( { \\hat { A } } , X )$ is essentially the gram matrix that measures the similarity between each pair of aggregated node features. ",
+        "bbox": [
+            174,
+            760,
+            826,
+            790
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Relationship Between $S ( { \\hat { A } } , X )$ and Gradient of SGC SGC $\\lVert \\rVert ^ { \\mathrm { ~ H ~ 2 ~ } }$ is one of the most simple but representative GNN models and its output can be written as: ",
+        "bbox": [
+            173,
+            796,
+            825,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/95cf7a885d41b67227ac3a2b3433da69158640f8cb38cba611ae308fa7636f03.jpg",
+        "text": "$$\nY = \\mathrm { s o f t m a x } ( \\hat { A } X W ) = \\mathrm { s o f t m a x } ( Y ^ { \\prime } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            829,
+            625,
+            848
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "With the loss function in equation $\\bigstar$ after each gradient descent step, we have $\\begin{array} { r } { \\Delta W = \\gamma \\frac { d \\mathcal { L } } { d W } } \\end{array}$ , where $\\gamma$ is the learning rate. The update of $Y ^ { \\prime }$ is (see Appendix $\\boxed { \\mathrm { E } }$ for derivation): ",
+        "bbox": [
+            173,
+            88,
+            826,
+            122
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f15311f214c17d5c72d4680017d87ac19b4c9915ba565f49aa85781e76738f6.jpg",
+        "text": "$$\n\\Delta Y ^ { \\prime } = \\hat { A } X \\Delta W = \\gamma \\hat { A } X { \\frac { d { \\mathcal { L } } } { d W } } \\propto \\hat { A } X { \\frac { d { \\mathcal { L } } } { d W } } = \\hat { A } X X ^ { T } \\hat { A } ^ { T } ( Z - Y ) = S ( \\hat { A } , X ) ( Z - Y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            127,
+            767,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $Z - Y$ is the prediction error matrix. The update direction of the prediction for node $i$ is essentially a weighted sum of the prediction error, i.e., $\\begin{array} { r } { \\Delta ( Y ^ { \\prime } ) _ { i , : } = \\sum _ { j \\in \\mathcal { V } } \\left[ S ( \\hat { A } , X ) \\right] _ { i , j } ( Z - Y ) _ { j , } } \\end{array}$ : and $\\big [ S ( \\hat { A } , X ) \\big ] _ { i , j }$ can be considered as the weights. Intuitively, a high similarity value $\\big [ S ( \\hat { A } , X ) \\big ] _ { i , j }$ means node $i$ tends to be updated to the same class as node $j$ . This indicates that $S ( { \\hat { A } } , X )$ is closely related to a single layer GNN model. ",
+        "bbox": [
+            173,
+            164,
+            826,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on the above definition and observation, we define the aggregation similarity score as follows. ",
+        "bbox": [
+            166,
+            255,
+            826,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. The aggregation similarity score is: ",
+        "bbox": [
+            173,
+            273,
+            503,
+            289
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/718052a1871048c44613af53ca96d5e828fddb61c949996ebd34574709cdee7a.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\left. { S _ { a g g } \\bigl ( S ( \\hat { A } , X ) \\bigr ) } \\quad } & { } \\\\ & { = \\frac { 1 } { | \\mathcal { V } | } \\left| \\left\\{ v \\big | \\operatorname { M e a n } _ { u } \\bigl ( \\{ S ( \\hat { A } , X ) _ { v , u } | Z _ { u , : } = Z _ { v , : } \\} \\right) \\geq \\operatorname { M e a n } _ { u } \\bigl ( \\{ S ( \\hat { A } , X ) _ { v , u } | Z _ { u , : } \\neq Z _ { v , : } \\} \\bigr ) \\right\\} \\right| } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            295,
+            789,
+            351
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\mathrm { M e a n } } _ { u } \\left( \\{ \\cdot \\} \\right)$ takes the average over u of a given multiset of values or variables. ",
+        "bbox": [
+            173,
+            357,
+            740,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$S _ { \\mathrm { a g g } } ( S ( \\hat { A } , X ) )$ measures the proportion of nodes $v \\in \\mathcal V$ as which the average weights on the set of nodes in the same class (including $v$ ) is larger than that in other classes. In practice, we observe that in most datasets, we will have $S _ { \\mathrm { a g g } } ( S ( { \\bar { A } } , X ) ) \\geq 0 . 5 ^ { 4 } .$ To make the metric range in [0,1], like existing metrics, we rescale equation $^ { 7 }$ to the following modified aggregation similarity, ",
+        "bbox": [
+            173,
+            385,
+            826,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8fc960b634cac84226929ed5a1d136c95e51172915cccd5332d0b8505b465a7f.jpg",
+        "text": "$$\nS _ { \\mathrm { a g g } } ^ { M } \\bigl ( S ( \\hat { A } , X ) \\bigr ) = \\bigl [ 2 S _ { \\mathrm { a g g } } \\bigl ( S ( \\hat { A } , X ) \\bigr ) - 1 \\bigr ] _ { + }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            450,
+            642,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to measure the consistency between labels and graph structures without considering node features and to make a fair comparison with the existing homophily metrics in equation $\\textcircled { 3 }$ we define the graph $( { \\mathcal { G } } )$ aggregation $( \\hat { A } )$ homophily and its modified version 5 as: ",
+        "bbox": [
+            173,
+            486,
+            825,
+            532
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29a24f44d7c5385bdfd8833b4453326ff078ca9effcd247b9c3c2a5c97c5193c.jpg",
+        "text": "$$\nH _ { \\mathrm { a g g } } ( \\mathcal { G } ) = S _ { \\mathrm { a g g } } \\big ( S ( \\hat { A } , Z ) \\big ) , H _ { \\mathrm { a g g } } ^ { M } ( \\mathcal { G } ) = S _ { \\mathrm { a g g } } ^ { M } \\big ( S ( \\hat { A } , Z ) \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            537,
+            678,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As the example shown in Figure $\\bigstar \\bigstar \\bigstar$ when $\\hat { A } = \\hat { A } _ { \\mathrm { r w } }$ , it is easy to see that $H _ { \\mathrm { a g g } } ( \\mathcal { G } ) = H _ { \\mathrm { a g g } } ^ { M } ( \\mathcal { G } ) = 1$ and other metrics are 0. Thus, this new metric reflects the fact that nodes in classes 1 and 2 are still highly distinguishable after aggregation, while other metrics mentioned before fail to capture such information and misleadingly give value 0. This shows the advantage of $H _ { \\mathrm { a g g } } ( { \\mathcal { G } } )$ and $H _ { \\mathrm { a g g } } ^ { M } ( { \\mathcal { G } } )$ , which additionally exploit information from aggregation operator $\\hat { A }$ and the similarity matrix. ",
+        "bbox": [
+            173,
+            566,
+            825,
+            645
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To comprehensively compare $H _ { \\mathrm { a g g } } ^ { M } ( { \\mathcal { G } } )$ with the existing metrics on their ability to elucidate the influence of graph structure on GNN performance, we generate synthetic graphs with different homophily levels and evaluate SGC $\\bar { \\| 4 2 \\| }$ and GCN $\\mathbb { I m }$ on them in the next subsection. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c95a51bb06fe7d52938b07387a269b7b689a3d8e5d1b6f893e2e8ce23be9f235.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of baseline performance under different homophily metrics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            718,
+            986,
+            832
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/abb5804f92603addff9a469f330855d8dbb69fa9416266712a781ee36aa03741.jpg",
+        "image_caption": [
+            "Figure 3: Example of how diversification can address harmful heterophily "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            90,
+            813,
+            233
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Empirical Evaluation and Comparison on Synthetic Graphs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            295,
+            630,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we conduct experiments on synthetic graphs generated with different levels of $H _ { \\mathrm { e d g e } } ^ { M } ( { \\mathcal { G } } )$ to assess the output of $\\dot { H } _ { \\mathrm { a g g } } ^ { M } ( { \\mathcal G } )$ in comparison with existing metrics. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Data Generation $\\pmb { \\& }$ Experimental Setup We first generated 10 graphs for each of 28 edge homophily levels, from 0.005 to 0.95, for a total of 280 graphs. In every generated graph, we had 5 classes, with 400 nodes in each class. For nodes in each class, we randomly generated 800 intra-class edges and $[ \\frac { 8 0 0 } { H _ { \\mathrm { e d g e } } ( \\mathcal { G } ) } - 8 0 0 ]$ inter-class edges. The features of nodes in each class are sampled from node features in the corresponding class of 6 base datasets (Cora, CiteSeer, PubMed, Chameleon, Squirrel, Film). Nodes were randomly split into train/validation/test sets, in proportion of $6 0 \\% / 2 0 \\% / 2 0 \\%$ . We trained 1-hop SGC (sgc-1) $| \\bar { | 4 2 | }$ and GCN $\\mathbb { \\underline { { \\ m o } } }$ on the synthetic graphs $\\bigstar$ For each value of $H _ { \\mathrm { e d g e } } ( { \\mathcal { G } } )$ , we take the average test accuracy and standard deviationthat value. For each generated graph, we also calculate $H _ { \\mathrm { n o d e } } ( \\mathcal G ) , H _ { \\mathrm { c l a s s } } ( \\mathcal G )$ geneand $H _ { \\mathrm { a g g } } ^ { M } ( { \\mathcal { G } } )$ phs with. Model performance with respect to different homophily values is shown in Figure 2. ",
+        "bbox": [
+            173,
+            356,
+            826,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Comparison of Homophily Metrics The performance of SGC-1 and GCN is expected to be monotonically increasing if the homophily metric is informative. However, Figure 2(a)(b)(c) show that the performance curves under $H _ { \\mathrm { e d g e } } ( \\mathcal { G } ) , H _ { \\mathrm { n o d e } } ( \\mathcal { G } )$ and $H _ { \\mathrm { c l a s s } } ( \\mathcal { G } )$ are $U$ -shaped ${ \\mathit { \\Sigma } } _ { . } ^ { 7 } ,$ while Figure 2(d) reveals a nearly monotonic curve with a little numerical perturbation around 1. This indicates that $\\overline { { H } } _ { \\mathrm { a g g } } ^ { M } ( \\mathcal { G } )$ provides a better indication of the way in which the graph structure affects the performance of SGC-1 and GCN than existing metrics. (See more discussion on aggregation homophily and theoretical results for regular graphs in Appendix $\\underline { { \\overline { { \\mathbb { D } } } } } .$ ",
+        "bbox": [
+            173,
+            506,
+            825,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Adaptive Channel Mixing (ACM) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            613,
+            485,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In prior work [32, 8, 4], it has been shown that high-frequency graph signals, which can be extracted by a high-pass filter (HP), is empirically useful for addressing heterophily. In this section, based on the similarity matrix in equation $\\mathbb { E } ,$ we theoretically prove that a diversification operation, i.e., HP filter, can address some cases of harmful heterophily locally. Besides, a node-wise analysis shows that different nodes may need different filters to process their neighborhood information. Based on the above analysis, in Sec. $^ { 4 . 2 }$ we propose Adaptive Channel Mixing (ACM), a 3-channel architecture which can adaptively exploit local and node-wise information from aggregation, diversification and identity channels. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Diversification Helps with Harmful Heterophily ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            760,
+            545,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first consider the example shown in Figure $3 .$ From $S ( { \\hat { A } } , X )$ , we can see that nodes $\\{ 1 , 3 \\}$ assign relatively large positive weights to nodes in class 2 after aggregation, which will make nodes $\\{ 1 , 3 \\}$ hard to be distinguished from nodes in class 2. However, we can still distinguish nodes $\\{ 1 , 3 \\}$ and $\\{ 4 , 5 , 6 , 7 \\}$ by considering their neighborhood differences: nodes $\\{ 1 , 3 \\}$ are different from most of their neighbors while nodes $\\{ 4 , 5 , 6 , 7 \\}$ are similar to most of their neighbors. This indicates that although some nodes become similar after aggregation, they are still distinguishable through their local surrounding dissimilarities. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This observation leads us to introduce the diversification operation, i.e., HP filter $I - { \\hat { A } } \\left[ \\mathbb { D } \\right] $ t o extract information regarding neighborhood differences, thereby addressing harmful heterophily. As $S ( I - { \\hat { A } } , X )$ in Fig. $\\textcircled { 3 }$ shows, nodes $\\{ 1 , 3 \\}$ will assign negative weights to nodes $\\{ 4 , 5 , 6 , 7 \\}$ after the diversification operation, i.e., nodes 1,3 treat nodes 4,5,6,7 as negative samples and will move away from them during backpropagation. This example reveals that there are cases in which the diversification operation is helpful to handle heterophily, while the aggregation operation is not. Based on this observation, we first define the diversification distinguishability of a node and the graph diversification distinguishability value, which measures the proportion of nodes for which the diversification operation is potentially helpful. ",
+        "bbox": [
+            173,
+            127,
+            825,
+            255
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Definition 2 (Diversification Distinguishability (DD) based on $S ( I - { \\hat { A } } , X ) )$ ). Given $S ( I - { \\hat { A } } , X )$ , $a$ node $v$ is diversification distinguishable if the following two conditions are satisfied at the same time, ",
+        "bbox": [
+            173,
+            261,
+            823,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b721ad959501bcbc8f830b4454e3a82e868b6a4ae7d4d45f8f07030f8da674d2.jpg",
+        "text": "$$\n\\begin{array} { r } { I . \\mathrm { ~ M e a n } _ { u } \\left( \\{ S ( I - \\hat { A } , X ) _ { v , u } | u \\in \\mathcal { V } \\wedge Z _ { u , : } = Z _ { v , : } \\} \\right) \\geq 0 ; } \\\\ { 2 . \\mathrm { ~ M e a n } _ { u } \\left( \\{ S ( I - \\hat { A } , X ) _ { v , u } | u \\in \\mathcal { V } \\wedge Z _ { u , : } \\neq Z _ { v , : } \\} \\right) \\leq 0 } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            292,
+            691,
+            349
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Then, graph diversification distinguishability value is defined as ",
+        "bbox": [
+            178,
+            356,
+            599,
+            372
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0b5fce6d96da716ecd383a1651c3adcabd2c0c3400d6cec64e4180094f8a96d.jpg",
+        "text": "$$\n\\mathrm { D D } _ { \\hat { A } , X } ( { \\mathcal G } ) = \\frac { 1 } { | \\mathcal V | } \\Big | \\{ v | v \\in \\mathcal V \\wedge v i s d i v e r s i f i c a t i o n d i s t i n g u i s h a b l e \\} \\Big |\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            377,
+            714,
+            410
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We can see that $\\mathrm { D D } _ { \\hat { A } , X } ( { \\mathcal G } ) \\in [ 0 , 1 ]$ . Based on Def. 2, the effectiveness of diversification in addressing heterophily can be theoretically proved under certain conditions: ",
+        "bbox": [
+            174,
+            419,
+            823,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. (See Appendix $\\mathbf { G }$ for proof). For $C = 2$ , suppose $X = Z , \\hat { A } = \\hat { A } _ { \\mathrm { r w } }$ . Then for any $I - { \\hat { A } } _ { \\mathrm { r w } }$ , all nodes are diversification distinguishable and $\\mathrm { D D } _ { \\hat { A } , Z } ( { \\mathcal G } ) = 1$ . ",
+        "bbox": [
+            173,
+            453,
+            820,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With the above results for HP filters, we will now introduce the concept of filterbank which combines both LP (aggregation) and HP (diversification) filters and can potentially handle various local heterophily cases. We then develop ACM framework in the following subsection. ",
+        "bbox": [
+            173,
+            494,
+            825,
+            537
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Filterbank and Adaptive Channel Mixing (ACM) Framework ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            545,
+            640,
+            560
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Filterbank For the graph signal $_ { \\textbf { \\em x } }$ defined on $\\mathcal { G }$ , a 2-channel linear (analysis) filterbank $\\underline { { \\breve { \\mathbb { I I } } } } | \\overline { { \\mathbb { I } } } |$ includes a pair of filters $H _ { \\mathrm { L P } } , H _ { \\mathrm { H P } }$ , which retain the low-frequency and high-frequency content of $_ { \\textbf { \\em x } }$ , respectively. Most existing GNNs use a uni-channel filtering architecture [19, 41, 15] with either LP or HP channel, which only partially preserves the input information. Unlike the uni-channel architecture, filterbanks with $H _ { \\mathrm { L P } } + H _ { \\mathrm { H P } } = I$ do not lose any information from the input signal, which is called the perfect reconstruction property [11]. Generally, the Laplacian matrices $( L _ { \\mathrm { s y m } } , L _ { \\mathrm { r w } } , \\hat { L } _ { \\mathrm { s y m } } , \\hat { L } _ { \\mathrm { r w } } )$ can be regarded as HP filters $\\mathbb { \\ m }$ and affinity matrices $ { \\langle A _ { \\mathrm { s y m } } }$ , $A _ { \\mathrm { r w } }$ , $\\hat { A } _ { \\mathrm { s y m } }$ , $\\hat { A } _ { \\mathrm { r w } } )$ can be treated as LP filters $\\pm \\pm \\pmb { \\mathbb { B 4 } } \\pmb { \\mathbb { B 4 } }$ . Moreover, we extend the concept of filterbank and view MLPs as using the identity (fullpass) filterbank with $H _ { \\mathrm { L P } } = I$ and $H _ { \\mathrm { H P } } = 0$ , which also satisfies $H _ { \\mathrm { L P } } + H _ { \\mathrm { H P } } = I + 0 = I .$ . ",
+        "bbox": [
+            173,
+            569,
+            616,
+            771
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/948c74e2e0a95c52ca6bfa8cd28e2de0781c1415f3b7b05909f8c2cf17024534.jpg",
+        "image_caption": [
+            "Figure 4: $H _ { \\mathrm { n o d e } } ^ { v }$ distributions "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            629,
+            593,
+            821,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Node-wise Channel Mixing for Diverse Local Homophily The example in Figure 3 also shows that different nodes may need the local information extracted from different channels, e.g., nodes $\\{ 1 , 3 \\}$ demand information from the HP channel while node 2 only needs information from the LP channel. Figure $\\sharp$ reveals that nodes have diverse distributions of node local homophily $H _ { \\mathrm { n o d e } } ^ { v }$ across different datasets. In order to adaptively leverage the LP, HP and identity channels in GNNs to deal with the diverse local heterophily situations, we will now describe our proposed Adaptive Channel Mixing (ACM) framework. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            876
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Adaptive Channel Mixing (ACM) We will use $\\operatorname { G C N } \\big \\lbrack$ as an example to introduce the ACM framework in matrix form, but the framework can be combined in a similar manner to many different GNNs. The ACM framework includes the following steps: ",
+        "bbox": [
+            174,
+            89,
+            826,
+            133
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Step 1. Feature Extraction for Each Channel: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            137,
+            491,
+            151
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Option 1: Option 2: $\\begin{array} { r l } & { \\colon H _ { L } ^ { l } = { \\mathrm { R e L U } } \\left( H _ { \\mathrm { L P } } H ^ { l - 1 } W _ { L } ^ { l - 1 } \\right) , H _ { H } ^ { l } = { \\mathrm { R e L U } } \\left( H _ { \\mathrm { R P } } H ^ { l - 1 } W _ { H } ^ { l - 1 } \\right) , H _ { I } ^ { l } = { \\mathrm { R e L U } } \\left( I H ^ { l - 1 } W _ { I } ^ { l - 1 } \\right) ; } \\\\ & { \\colon H _ { L } ^ { l } = H _ { \\mathrm { L P } } { \\mathrm { R e L U } } \\left( H ^ { l - 1 } W _ { L } ^ { l - 1 } \\right) , H _ { H } ^ { l } = H _ { \\mathrm { H P } } { \\mathrm { R e L U } } \\left( H ^ { l - 1 } W _ { H } ^ { l - 1 } \\right) , H _ { I } ^ { l } = I { \\mathrm { R e L U } } \\left( H ^ { l - 1 } W _ { I } ^ { l - 1 } \\right) ; } \\end{array}$ $H ^ { 0 } = X \\in \\mathbb { R } ^ { N \\times F _ { 0 } }$ , $W _ { L } ^ { l - 1 }$ , $W _ { H } ^ { l - 1 }$ , $W _ { I } ^ { l - 1 } \\in \\mathbb { R } ^ { F _ { l - 1 } \\times F _ { l } }$ , l = 1, . . . , L; ",
+        "bbox": [
+            173,
+            154,
+            875,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Step 2. Row-wise Feature-based Weight Learning: ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            218,
+            526,
+            232
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a2a6c6d66e21705abb42a87cde03ee9e1bb35e6d692aa36ced9ee9b5ac9e47c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { 1 \\left( H _ { L } ^ { l } \\tilde { W } _ { L } ^ { l } \\right) , \\tilde { \\alpha } _ { H } ^ { l } = \\mathrm { S i g m o i d } \\left( H _ { H } ^ { l } \\tilde { W } _ { H } ^ { l } \\right) , \\tilde { \\alpha } _ { I } ^ { l } = \\mathrm { S i g m o i d } \\left( H _ { I } ^ { l } \\tilde { W } _ { I } ^ { l } \\right) , \\tilde { W } _ { L } ^ { l - 1 } , \\tilde { W } _ { H } ^ { l - 1 } , \\tilde { W } _ { I } ^ { l - 1 } \\in \\mathbb { R } ^ { F _ { l } \\times 1 } } \\\\ & { = \\mathrm { S o f t m a x } \\left( \\left( \\left[ \\tilde { \\alpha } _ { L } ^ { l } , \\tilde { \\alpha } _ { H } ^ { l } , \\tilde { \\alpha } _ { I } ^ { l } \\right] / T \\right) W _ { \\mathrm { M i x } } ^ { l } \\right) \\in \\mathbb { R } ^ { N \\times 3 } , T \\in \\mathbb { R } \\mathrm { ~ t e m p e r a u r e } , W _ { \\mathrm { M i x } } ^ { l } \\in \\mathbb { R } ^ { 3 \\times 3 } ; } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            234,
+            921,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Step 3. Node-wise Adaptive Channel Mixing: ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            285,
+            488,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/424e1ff3ce646f7d18bb472122bce2f97772bbe80055bea2fecd2add8421323a.jpg",
+        "text": "$$\nH ^ { l } = \\mathrm { R e L U } \\left( \\mathrm { d i a g } ( \\alpha _ { L } ^ { l } ) H _ { L } ^ { l } + \\mathrm { d i a g } ( \\alpha _ { H } ^ { l } ) H _ { H } ^ { l } + \\mathrm { d i a g } ( \\alpha _ { I } ^ { l } ) H _ { I } ^ { l } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            303,
+            570,
+            321
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We will refer to the instantiation which uses option 1 in step 1 as ACM and to the one using option 2 as $\\mathsf { A C M I I } \\boxed { 1 0 }$ In step 1, ACM(II)-GCN implement different feature extractions for 3 channels using a set of filterbanks. Three filtered components, $H _ { L } ^ { l } , H _ { H } ^ { l } , H _ { I } ^ { l }$ , are obtained. To adaptively exploit information from each channel, ACM(II)-GCN first extract nonlinear information from the filtered signals, then use $W _ { \\mathrm { M i x } } ^ { l }$ to learn which channel is important for each node, leading to the row-wise weight vectors $\\alpha _ { L } ^ { l } , \\widetilde { \\alpha _ { H } ^ { l } } , \\alpha _ { I } ^ { l } \\in \\mathbb { R } ^ { N \\times 1 }$ whose $i$ -th elements are the weights for node $i$ L 11 These three vectors are then used as weights in defining the updated $H ^ { l }$ in step 3. ",
+        "bbox": [
+            173,
+            327,
+            825,
+            429
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Complexity The number of learnable parameters in layer $l$ of ACM(II)-GCN is $3 F _ { l - 1 } ( F _ { l } + 1 ) + 9$ , compared to $F _ { l - 1 } F _ { l }$ in GCN. The computation of steps 1-3 takes $N F _ { l } ( 8 + 6 F _ { l - 1 } ) + 2 F _ { l } ( \\mathrm { n n z } ( H _ { \\mathrm { L P } } ) +$ $\\mathrm { n n z } ( H _ { \\mathrm { H P } } ) ) + 1 8 N$ flops, while the GCN layer takes $2 N F _ { l - 1 } F _ { l } + 2 F _ { l } ( \\mathrm { n n z } ( H _ { \\mathrm { L P } } ) )$ flops, where $\\mathrm { n n z } ( \\cdot )$ is the number of non-zero elements. An ablation study and a detailed comparison on running time are conducted in Sec. 6.1. ",
+        "bbox": [
+            173,
+            435,
+            826,
+            506
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Limitations of Diversification Like any other method, there exists some cases of harmful heterophily that diversification operation cannot work well. For example, suppose we have an imbalanced dataset where several small clusters with distinctive labels are densely connected to a large cluster. In this case, the surrounding differences of nodes in small clusters are similar, i.e., the neighborhood differences mainly come from their connections to the same large cluster, and this can lead to the diversification operation failing to discriminate them. See Appendix $\\mathrm { ~ H ~ }$ for a more detailed discussion. ",
+        "bbox": [
+            173,
+            512,
+            826,
+            597
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            604,
+            323,
+            621
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We now discuss relevant work on addressing heterophily in GNNs. [1] acknowledges the difficulty of learning on graphs with weak homophily and propose MixHop to extract features from multi-hop neighborhoods to get more information. $\\mathbb { \\lVert 1 7 \\rVert }$ propose measurements based on feature smoothness and label smoothness that are potentially helpful to guide GNNs when dealing with heterophilic graphs. Geom-GCN $[ \\beta 6 ]$ precomputes unsupervised node embeddings and uses the graph structure defined by geometric relationships in the embedding space to define the bi-level aggregation process to handle heterophily. $\\mathrm { H _ { 2 } G C N }$ [46] combines 3 key designs to address heterophily: (1) ego- and neighbor-embedding separation; (2) higher-order neighborhoods; (3) combination of intermediate representations. CPGNN $\\lVert \\rVert \\dot { \\boldsymbol { \\mathrm { \\Omega } } }$ models label correlations through a compatibility matrix, which is beneficial for heterophilic graphs, and propagates a prior belief estimation into the GNN by using the compatibility matrix. Non-local GNNs $\\pmb { \\Vert 2 8 \\Vert }$ propose a simple and effective non-local aggregation framework with an efficient attention-guided sorting for GNNs. FAGCN [4] learns edge-level aggregation weights as GAT $\\mathbb { H }$ but allows the weights to be negative, which enables the network to capture high-frequency components in the graph signals. GPRGNN [8] uses learnable weights that can be both positive and negative for feature propagation. This allows GPRGNN to adapt to heterophilic graphs and to handle both high- and low-frequency parts of the graph signals (See Appendix J for a more comprehensive comparison between ACM-GNNs, ACMII-GNNs and FAGCN, ",
+        "bbox": [
+            173,
+            625,
+            826,
+            859
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "GPRGNN). BernNet [16] designs a scheme to learn arbitrary graph spectral filters with Bernstein polynomial to address heterophily. $\\pmb { \\Vert 3 3 \\Vert }$ points out that homophily is not necessary for GNNs and characterizes conditions that GNNs can perform well on heterophilic graphs. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            133
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 Empirical Evaluation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            147,
+            385,
+            164
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the proposed ACM and ACMII framework on real-world datasets (see Appendix $\\boxed { \\mathbf { D . 2 } }$ for a performance comparison with basline models on synthetic datasets). We first conduct ablation studies in Sec. 6.1 to validate the effectiveness and efficiency of different components of ACM and ACMII. Then, we compare with state-of-the-art (SOTA) models in Sec. 6.2. The hyperparameter searching range and computing resources are described in Appendix C. ",
+        "bbox": [
+            173,
+            170,
+            825,
+            239
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/06b082d90bb15827608044fd54d9bb9b958aed44d5b74f2466f243d2ba99013d.jpg",
+        "image_caption": [
+            "Figure 5: t-SNE visualization of the output layer of ACM-GCN and GCN trained on Squirrel "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            265,
+            792,
+            583
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 Ablation Study & Efficiency ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            633,
+            408,
+            648
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We will now investigate the effectiveness and efficiency of adding HP, identity channels and the adaptive mixing mechanism in the proposed framework by performing an ablation study. Specifically, we apply the components of ACM to SGC-1 [42] $\\boxed { 1 2 }$ and the components of ACM and ACMII to GCN $\\mathbb { \\lVert 1 9 \\rVert }$ separately. We run 10 times on each of the 9 benchmark datatsets, Cornell, Wisconsin, Texas, Film, Chameleon, Squirrel, Cora, Citeseer and Pubmed used in $[ \\beta 7 , \\left| 3 6 \\right| ]$ , with the same $6 0 \\% / 2 0 \\% / 2 0 \\%$ random splits for train/validation/test used in $\\pmb { \\Vert 8 \\Vert }$ and report the average test accuracy as well as the standard deviation. We also record the average running time per epoch (in milliseconds) to compare the computational efficiency. We set the temperature $T$ in equation $^ { 4 . 2 }$ to be 3, which is the number of channels. ",
+        "bbox": [
+            173,
+            656,
+            825,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results in Table 1 show that on most datasets, the additional HP and identity channels are helpful, even for strong homophily datasets such as Cora, CiteSeer and PubMed. The adaptive mixing mechanism also has an advantage over directly adding the three channels together. This illustrates the necessity of learning to customize the channel usage adaptively for different nodes. The t-SNE visualization in Figure $\\bar { 5 }$ demonstrates that the high-pass channel(e) and identity channel(f) can extract meaningful patterns, which the low-pass channel(d) is not able to capture. The output of ACM",
+        "bbox": [
+            173,
+            787,
+            825,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/8555cb111c0a02b3cffb5bb7ab465a5405e75ffbd0a05401c71111930d5edd6f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Ablation Study on Different Components in ACM-SGC and ACM-GCN (%)</td><td></td><td colspan=\"10\"></td><td></td></tr><tr><td>Baseline</td><td colspan=\"3\">ModelComponents</td><td>Cornell</td><td>Wisconsin</td><td>Texas</td><td>Film</td><td>Chameleon</td><td>Squirrel</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td><td>Rank</td></tr><tr><td>Models</td><td colspan=\"3\">LP HP Identity Mixing|</td><td>Acc ± Std</td><td>Acc ± Std</td><td>Acc ± Std</td><td>Acc ± Std</td><td>Acc ± Std</td><td>Acc ± Std</td><td>Acc ± Std</td><td>Acc ± Std</td><td>Acc ± Std</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>70.98±8.39 70.38±2.85 83.28±5.43 25.26±1.18 64.86±1.8147.62±1.2785.12±1.64 79.66±0.7585.5±0.76</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>12.89</td></tr><tr><td>ACM-SGC-1 w/</td><td>√</td><td></td><td>√ √</td><td></td><td>83.28±5.8191.88±1.6190.98±2.46 36.76±1.0165.27±1.947.27±1.3786.8±1.0880.98±1.68 87.21±0.42</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>10.44</td></tr><tr><td></td><td>√ √</td><td>√</td><td></td><td>93.93±3.695.25±1.84 93.93±2.54 38.38±1.13 63.83±2.0746.79±0.7586.73±1.2880.57±0.9987.8±0.58</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>9.44</td></tr><tr><td></td><td>√ √ √</td><td>√</td><td></td><td></td><td>88.2 ±4.3993.5±2.95 92.95±2.94 37.19±0.87 62.82±1.84 4.94±0.93 85.22±1.35 80.75±1.68 88.11±0.21</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>11.00</td></tr><tr><td></td><td></td><td>√</td><td>√</td><td></td><td>93.77±1.9193.25±2.9293.61±1.5539.33±1.2563.68±1.6246.4±1.1386.63±1.1380.96±0.9387.75±0.88</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>10.00</td></tr><tr><td>ACM-GCN w/</td><td>√</td><td></td><td></td><td>82.46±3.11 75.5±2.9283.11±3.2 35.51±0.99 64.18±2.62 44.76±1.39 87.78±0.96 81.39±1.2388.9±0.32</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>11.44</td></tr><tr><td></td><td>√ √</td><td></td><td>√</td><td></td><td>82.13 ±2.59 86.62±4.6189.19 ±3.04 38.06±1.3569.21±1.6857.2±1.018.93±1.5581.96±0.9190.01±0.8</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>7.22</td></tr><tr><td></td><td>√ √</td><td>√</td><td>√</td><td></td><td>94.26±2.2396.13±2.294.1±2.9541.51±0.99 67.44±2.14 53.97±1.3988.95±0.981.72±1.22 90.88±0.55</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>4.44</td></tr><tr><td></td><td>√</td><td>√</td><td></td><td></td><td>91.64±295.37±3.3195.25±2.3740.47±1.49 68.93±2.04 54.78±1.2789.13±1.7781.96±2.0391.01±0.7</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>3.11</td></tr><tr><td></td><td>√ √</td><td>√</td><td>√</td><td></td><td>94.75±2.6296.75±1.695.08±3.241.62±1.15 69.04±1.7458.02±1.8688.95±1.381.80±1.2690.69±0.53</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>2.78</td></tr><tr><td>ACMII-GCN w/</td><td>√ √</td><td></td><td>√</td><td>82.46±3.03 91.00±1.7590.33±2.69 38.39±0.75 67.59±2.1453.67±1.7189.13±1.1481.75±0.85 89.87±0.39</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>7.44</td></tr><tr><td></td><td>√</td><td>√</td><td>√</td><td>94.26±2.57 96.00±2.15 94.26 ±2.96 40.96±1.2 66.35±1.76 50.78±2.0789.06±1.0781.86±1.22 90.71±0.67</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>4.67</td></tr><tr><td></td><td>√ √</td><td>√</td><td></td><td>91.48±1.43 96.25±2.09 93.77±2.9140.27±1.076.52±2.65 52.9±1.6488.83±1.1681.54±0.9590.6±0.47</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>6.67</td></tr><tr><td></td><td>√ √</td><td>√</td><td>√</td><td></td><td>95.9±1.8396.62±2.4495.25±3.1541.84±1.1568.38±1.36 54.53±2.0989.00±0.7281.79±0.9590.74±0.5</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>2.78</td></tr><tr><td colspan=\"14\">Comparison of Average Running Time Per Epoch(ms)</td></tr><tr><td></td><td></td><td></td><td></td><td>2.53</td><td>2.83</td><td></td><td></td><td></td><td></td><td>3.47</td><td>3.43</td><td></td></tr><tr><td></td><td>√ √ √</td><td></td><td>√</td><td>4.01</td><td>4.57</td><td>2.5 4.24</td><td>3.18 4.55</td><td>3.48 4.76</td><td>4.65 5.09</td><td>5.39</td><td>4.69</td><td>4.04 4.75</td><td></td></tr><tr><td>ACM-SGC-1 w/</td><td>√</td><td>√</td><td>√</td><td>3.88</td><td>4.01</td><td>4.04</td><td>4.43</td><td>4.06</td><td>4.5</td><td>4.38</td><td>3.82</td><td>4.16</td><td></td></tr><tr><td></td><td>√ √</td><td>√</td><td></td><td>3.31</td><td>3.49</td><td>3.18</td><td>3.7</td><td>3.53</td><td>4.83</td><td>3.92</td><td>3.87</td><td>4.24</td><td></td></tr><tr><td></td><td>√ √</td><td>√</td><td>√</td><td>5.53</td><td>5.96</td><td>5.43</td><td>5.21</td><td>5.41</td><td>6.96</td><td>6</td><td>5.9</td><td>6.04</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>3.67</td><td>3.74</td><td>3.59</td><td></td><td></td><td></td><td></td><td>4.18</td><td>5.08</td><td></td></tr><tr><td></td><td>√ √ √</td><td></td><td>√</td><td>6.63</td><td>8.06</td><td>7.89</td><td>4.86 8.11</td><td>4.96 7.8</td><td>6.41 9.39</td><td>4.24 7.82</td><td>7.38</td><td>8.74 6.8</td><td></td></tr><tr><td>ACM-GCN w/</td><td>√</td><td>√</td><td>√</td><td>5.73</td><td>5.91</td><td>5.93</td><td>6.86</td><td>6.35</td><td>7.15</td><td>7.34</td><td>6.65</td><td>6.16</td><td></td></tr><tr><td></td><td>√ √</td><td>√</td><td></td><td>5.16</td><td>5.25</td><td>5.2</td><td>5.93</td><td>5.64</td><td>8.02</td><td>5.73</td><td>5.65</td><td></td><td></td></tr><tr><td></td><td>√ √</td><td>√</td><td>√</td><td>8.25</td><td>8.11</td><td>7.89</td><td>7.97</td><td>8.41</td><td>11.9</td><td>8.84</td><td>8.38</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>√ √</td><td></td><td>√</td><td>6.62</td><td>7.35</td><td>7.39</td><td>7.62</td><td>7.33</td><td>9.69</td><td>7.49</td><td>7.58</td><td></td><td></td></tr><tr><td>ACMII-GCNw/</td><td>√</td><td>√</td><td>√</td><td>6.3</td><td>6.05</td><td>6.26</td><td>6.87</td><td>6.44</td><td>6.5</td><td>6.14</td><td>7.21</td><td>7.97 6.6 6.33</td><td></td></tr><tr><td></td><td>√ √ √ √</td><td>√ √</td><td>√</td><td>5.24 7.59</td><td>5.27 8.28</td><td>5.46 8.06</td><td>5.72 8.85</td><td>5.65 8</td><td>7.87 10</td><td>5.48 8.27</td><td>5.65 8.5</td><td>8.68</td><td></td></tr><tr><td></td></table>",
+        "bbox": [
+            173,
+            90,
+            877,
+            443
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Ablation study on 9 real-world datasets $\\pmb { \\mathbb { B } } 6 \\|$ . Cell with Xmeans the component is applied to the baseline model. The best test results are highlighted. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "GCN(c) shows clearer boundaries among classes than GCN(b). The running time is approximately doubled in the ACM and ACMII framework compared to the original models. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            540
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 Comparison with Baseline and SOTA Models ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            546,
+            529,
+            561
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Datasets & Experimental Setup In this section, we evaluate SGC $[ \\mathbb { A } 2 ]$ with 1 hop and 2 hops (SGC-1, SGC-2), GCNII [7], GCNII⇤ [7], GCN $\\mathbb { \\ m }$ and snowball networks $\\pmb { \\| } \\pmb { \\bigtriangledown } $ with 2 and 3 layers (snowball-2, snowball-3) and combine them with the ACM or ACMII framework13. We use $\\hat { A } _ { \\mathrm { r w } } ^ { \\dagger }$ as the LP filter and the corresponding HP filter is $I - { \\hat { A } } _ { \\mathrm { r w } } \\big \\lbrack { \\boldsymbol { 1 4 } } \\big \\rbrack$ Both filters are deterministic. We compare these approaches with several baselines and SOTA GNN models: MLP with 2 layers (MLP-2), GAT [41], APPNP $\\mathbb { \\left[ \\left[ 2 0 \\right] \\right] }$ , GPRGNN $\\pmb { \\mathbb { B } } ] \\mathbf  l$ , $\\mathrm { H _ { 2 } G C N }$ [46], MixHop $\\mathbb { M }$ , $\\mathrm { G C N + J K }$ [19, 43, 26], $\\mathrm { G A T + J K }$ [41, 43, 26], FAGCN [4], GraphSAGE $\\mathbb { \\left[ \\left[ \\bar { 1 } \\bar { 5 } \\right] \\right] }$ , Geom-GCN $\\left[ \\left[ 3 6 \\right] \\right]$ and BernNet [16]. In addition to the 9 benchmark datasets used in section $6 . 1 ,$ we further test the above models on a new benchmark dataset, Deezer-Europe [38]15. ",
+        "bbox": [
+            173,
+            565,
+            826,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On each dataset used in $\\textcircled { 1 3 7 } , \\textcircled { 3 6 } \\textcircled { 1 }$ , we test the models 10 times following the same early stopping strategy, the same $6 0 \\% / 2 0 \\% / 2 0 \\%$ random data split $^ { 1 6 }$ and Adam $\\boxed { 1 8 }$ optimizer as used in GPRGNN $\\pmb { \\mathbb { B } } \\|$ . For Deezer-Europe, we test the above models 5 times with the same early stopping strategy, the same fixed splits and Adam used in $\\pmb { \\mathbb { D } } \\pmb { \\ 6 } \\|$ . ",
+        "bbox": [
+            173,
+            700,
+            825,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Structure information channel and residual connection Besides the filtered features, some recent SOTA models additionally use graph structure information, i.e., $\\mathrm { M L P } _ { \\theta } ( A )$ , and residual connection to address heterophily problem, e.g., LINKX $\\pmb { \\Vert 2 5 \\Vert }$ and GloGNN $\\pmb { \\mathbb { Z } } 4 \\mathbb { I }$ . $\\operatorname { M L P } _ { \\theta } ( A )$ and residual connection can be directly incorporated into ACM and ACMII framework, which leads us to ACM(II)- ${ \\mathrm { . G C N } } +$ and ACM(II)- $\\mathrm { G C N + + }$ . See the details of implementation in Appendix B. ",
+        "bbox": [
+            173,
+            761,
+            825,
+            832
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/c2317f25ac17c47b2c2adcd91fddc0282fbefedf72865098382678ee0912eb14.jpg",
+        "image_caption": [
+            "Figure 6: Comparison of baseline GNNs (red), ACM-GNNs (green), ACMII-GNNs (blue) with SOTA (magenta line) models on 6 selected datasets. The black lines indicate the standard deviation. The symbol “\"” shows the range of performance improvement $( \\% )$ of ACM-GNNs and ACMII-GNNs over baseline GNNs. See Appendix I for a detailed discussion of the relation between $H _ { \\mathrm { a g g } } ^ { M }$ and GNN performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            931,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To visualize the performance, in Fig. $\\bigtriangledown$ we plot the bar charts of the test accuracy of SOTA models, three selected baselines (GCN, snowball-2, snowball-3), their ACM(II) augmented models, ACM(II)- $\\mathrm { G C N + }$ and ACM(II)- $\\mathrm { G C N + + }$ on the 6 most commonly used benchmark heterophily datasets (See Table 2 in Appendix $\\mathbf { A . l }$ for the full results, comparison and ranking). From Fig. $6 ,$ we can see that (1) after being combined with the ACM or ACMII framework, the performance of the three baseline models is significantly boosted, by $2 . 0 4 \\% \\sim 2 7 . 5 0 \\%$ on all the 6 tasks. The ACM and ACMII in fact achieve SOTA performance. (2) On Cornell, Wisconsin, Texas, Chameleon and Squirrel, the augmented baseline models significantly outperform the current SOTA models. Overall, these results suggest that the proposed approach can help GNNs to generalize better on node classification tasks on heterophilic graphs, without adding too much computational cost. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusions and Limitations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            631,
+            444,
+            647
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have presented an analysis of existing homophily metrics and proposed new metrics which are more informative in terms of correlating with GNN performance. To our knowledge, this is the first work analyzing heterophily from the perspective of post-aggregation node similarity. The similarity matrix and the new metrics we defined mainly capture linear feature-independent relationships of each node. This might be insufficient when nonlinearity and feature-dependent information is important for classification. In the future, it would be useful to investigate if a similarity matrix could be defined which is capable of capturing nonlinear and feature-dependent relations between aggregated node. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have also proposed a multi-channel mixing mechanism which leverages the intuitions gained in the first part of the paper and can be combined with different GNN architectures, enabling adaptive filtering (high-pass, low-pass or identity) at different nodes. Empirically, this approach shows very promising results, improving the performance of the base GNNs with which it is combined and achieving SOTA results at the cost of a reasonable increase in computation time. As discussed in Sec. $\\boxed { 4 . 2 } ,$ however, the filterbank method cannot properly handle all cases of harmful heterophily, and alternative ideas should be explored as well in the future. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            851
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 Acknowledge ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            859,
+            316,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to give very special thanks to William L. Hamilton for valuable discussion and advice. The project was partially supported by DeepMind and NSERC. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] S. Abu-El- Haija, Kapoor, Alipourfard, Lerman, G. Ver Steeg, and A. Galstyan. Mixhop: Higher-order graph convolutional architectures via sparsified neighborhood mixing. In international conference on machine learning, pages 21–29. PMLR, 2019. [2] D. Bahdanau, K. Cho, and Y. Bengio. Neural machine translation by jointly learning to align and translate. arXiv preprint arXiv:1409.0473, 2014. [3] P. W. Battaglia, J. B. Hamrick, V. Bapst, A. Sanchez-Gonzalez, V. Zambaldi, M. Malinowski, A. Tacchetti, D. Raposo, A. Santoro, R. Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018. [4] D. Bo, X. Wang, C. Shi, and H. Shen. Beyond low-frequency information in graph convolutional networks. arXiv preprint arXiv:2101.00797, 2021. [5] C. Bodnar, F. Di Giovanni, B. P. Chamberlain, P. Liò, and M. M. Bronstein. Neural sheaf diffusion: A topological perspective on heterophily and oversmoothing in gnns. arXiv preprint arXiv:2202.04579, 2022. [6] M. M. Bronstein, J. Bruna, Y. LeCun, A. Szlam, and P. Vandergheynst. Geometric deep learning: going beyond euclidean data. arXiv, abs/1611.08097, 2016. [7] M. Chen, Z. Wei, Z. Huang, B. Ding, and Y. Li. Simple and deep graph convolutional networks. In International Conference on Machine Learning, pages 1725–1735. PMLR, 2020. [8] E. Chien, J. Peng, P. Li, and O. Milenkovic. Adaptive universal generalized pagerank graph neural network. In International Conference on Learning Representations. https://openreview. net/forum, 2021. [9] F. R. Chung and F. C. Graham. Spectral graph theory. Number 92. American Mathematical Soc., 1997.   \n[10] M. Defferrard, X. Bresson, and P. Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. arXiv, abs/1606.09375, 2016.   \n[11] V. N. Ekambaram. Graph structured data viewed through a fourier lens. University of California, Berkeley, 2014.   \n[12] M. Fey and J. E. Lenssen. Fast graph representation learning with pytorch geometric. arXiv preprint arXiv:1903.02428, 2019.   \n[13] A. Graves, A.-r. Mohamed, and G. Hinton. Speech recognition with deep recurrent neural networks. In 2013 IEEE international conference on acoustics, speech and signal processing, pages 6645–6649. Ieee, 2013.   \n[14] W. L. Hamilton. Graph representation learning. Synthesis Lectures on Artifical Intelligence and Machine Learning, 14(3):1–159, 2020.   \n[15] W. L. Hamilton, R. Ying, and J. Leskovec. Inductive representation learning on large graphs. arXiv, abs/1706.02216, 2017.   \n[16] M. He, Z. Wei, H. Xu, et al. Bernnet: Learning arbitrary graph spectral filters via bernstein approximation. Advances in Neural Information Processing Systems, 34, 2021.   \n[17] Y. Hou, J. Zhang, J. Cheng, K. Ma, R. T. Ma, H. Chen, and M.-C. Yang. Measuring and improving the use of graph information in graph neural networks. In International Conference on Learning Representations, 2019.   \n[18] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.   \n[19] T. N. Kipf and M. Welling. Semi-supervised classification with graph convolutional networks. arXiv, abs/1609.02907, 2016.   \n[20] J. Klicpera, A. Bojchevski, and S. Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. arXiv preprint arXiv:1810.05997, 2018.   \n[21] A. Krizhevsky, I. Sutskever, and G. E. Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pages 1097–1105, 2012.   \n[22] Y. LeCun, Y. Bengio, and G. Hinton. Deep learning. nature, 521(7553):436, 2015.   \n[23] Y. LeCun, L. Bottou, Y. Bengio, P. Haffner, et al. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.   \n[24] X. Li, R. Zhu, Y. Cheng, C. Shan, S. Luo, D. Li, and W. Qian. Finding global homophily in graph neural networks when meeting heterophily. arXiv preprint arXiv:2205.07308, 2022.   \n[25] D. Lim, F. Hohne, X. Li, S. L. Huang, V. Gupta, O. Bhalerao, and S. N. Lim. Large scale learning on non-homophilous graphs: New benchmarks and strong simple methods. Advances in Neural Information Processing Systems, 34:20887–20902, 2021.   \n[26] D. Lim, X. Li, F. Hohne, and S.-N. Lim. New benchmarks for learning on non-homophilous graphs. arXiv preprint arXiv:2104.01404, 2021.   \n[27] V. Lingam, R. Ragesh, A. Iyer, and S. Sellamanickam. Simple truncated svd based model for node classification on heterophilic graphs. arXiv preprint arXiv:2106.12807, 2021.   \n[28] M. Liu, Z. Wang, and S. Ji. Non-local graph neural networks. arXiv preprint arXiv:2005.14612, 2020.   \n[29] M. Liu, Z. Wang, and S. Ji. Non-local graph neural networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 2021.   \n[30] S. Luan, M. Zhao, X.-W. Chang, and D. Precup. Break the ceiling: Stronger multi-scale deep graph convolutional networks. arXiv preprint arXiv:1906.02174, 2019.   \n[31] S. Luan, M. Zhao, X.-W. Chang, and D. Precup. Training matters: Unlocking potentials of deeper graph convolutional neural networks. arXiv preprint arXiv:2008.08838, 2020.   \n[32] S. Luan, M. Zhao, C. Hua, X.-W. Chang, and D. Precup. Complete the missing half: Augmenting aggregation filtering with diversification for graph convolutional networks. arXiv preprint arXiv:2008.08844, 2020.   \n[33] Y. Ma, X. Liu, N. Shah, and J. Tang. Is homophily a necessity for graph neural networks? arXiv preprint arXiv:2106.06134, 2021.   \n[34] T. Maehara. Revisiting graph neural networks: All we have is low-pass filters. arXiv preprint arXiv:1905.09550, 2019.   \n[35] M. McPherson, L. Smith-Lovin, and J. M. Cook. Birds of a feather: Homophily in social networks. Annual review of sociology, 27(1):415–444, 2001.   \n[36] H. Pei, B. Wei, K. C.-C. Chang, Y. Lei, and B. Yang. Geom-gcn: Geometric graph convolutional networks. arXiv preprint arXiv:2002.05287, 2020.   \n[37] B. Rozemberczki, C. Allen, and R. Sarkar. Multi-Scale Attributed Node Embedding. Journal of Complex Networks, 9(2), 2021.   \n[38] B. Rozemberczki and R. Sarkar. Characteristic Functions on Graphs: Birds of a Feather, from Statistical Descriptors to Parametric Models. In Proceedings of the 29th ACM International Conference on Information and Knowledge Management (CIKM ’20), page 1325–1334. ACM, 2020.   \n[39] F. Scarselli, M. Gori, A. C. Tsoi, M. Hagenbuchner, and G. Monfardini. The graph neural network model. IEEE transactions on neural networks, 20(1):61–80, 2008.   \n[40] P. Vary. An adaptive filter-bank equalizer for speech enhancement. Signal Processing, 86(6):1206–1214, 2006.   \n[41] P. Velickovic, G. Cucurull, A. Casanova, A. Romero, P. Lio, and Y. Bengio. Graph attention networks. arXiv, abs/1710.10903, 2017.   \n[42] F. Wu, T. Zhang, A. H. d. Souza Jr, C. Fifty, T. Yu, and K. Q. Weinberger. Simplifying graph convolutional networks. arXiv preprint arXiv:1902.07153, 2019.   \n[43] K. Xu, C. Li, Y. Tian, T. Sonobe, K.-i. Kawarabayashi, and S. Jegelka. Representation learning on graphs with jumping knowledge networks. In J. Dy and A. Krause, editors, Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 5453–5462. PMLR, 10–15 Jul 2018.   \n[44] Y. Yan, M. Hashemi, K. Swersky, Y. Yang, and D. Koutra. Two sides of the same coin: Heterophily and oversmoothing in graph convolutional neural networks. arXiv preprint arXiv:2102.06462, 2021.   \n[45] J. Zhu, R. A. Rossi, A. Rao, T. Mai, N. Lipka, N. K. Ahmed, and D. Koutra. Graph neural networks with heterophily. arXiv preprint arXiv:2009.13566, 2020.   \n[46] J. Zhu, Y. Yan, L. Zhao, M. Heimann, L. Akoglu, and D. Koutra. Beyond homophily in graph neural networks: Current limitations and effective designs. Advances in Neural Information Processing Systems, 33, 2020. ",
+        "bbox": [
+            173,
+            126,
+            828,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            73,
+            828,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            826,
+            166
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            227
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            231,
+            493,
+            244
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] ",
+        "bbox": [
+            236,
+            248,
+            735,
+            280
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            285,
+            393,
+            299
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            303,
+            826,
+            421
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            426,
+            823,
+            440
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [No]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] ",
+        "bbox": [
+            238,
+            444,
+            823,
+            551
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            556,
+            705,
+            570
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            574,
+            825,
+            665
+        ],
+        "page_idx": 13
+    }
+]

parse/dev/QkRV50TZyP/QkRV50TZyP.md

@@ -0,0 +1,412 @@
+# BEYOND IMAGENET ATTACK: TOWARDS CRAFTINGADVERSARIAL EXAMPLES FOR BLACK-BOX DOMAINS
+
+Qilong Zhang1∗, Xiaodan $\mathbf { L i } ^ { 2 }$ , Yuefeng Chen2, Jingkuan Song1†,   
+Lianli $\mathbf { G a o ^ { 1 } }$ , Yuan $\mathbf { H e } ^ { 2 }$ , and Hui $\mathbf { X } \mathbf { u } \mathbf { e } ^ { 2 }$   
+1University of Electronic Science and Technology of China, China   
+qilong.zhang $@$ std.uestc.edu.cn, jingkuan.song $@$ gmail.com, lianli.gao $@$ uestc.edu.cn   
+2Alibaba Group, China   
+{fiona.lxd,yuefeng.chenyf,heyuan.hy,hui.xueh}@alibaba-inc.com
+
+# ABSTRACT
+
+Adversarial examples have posed a severe threat to deep neural networks due to their transferable nature. Currently, various works have paid great efforts to enhance the cross-model transferability, which mostly assume the substitute model is trained in the same domain as the target model. However, in reality, the relevant information of the deployed model is unlikely to leak. Hence, it is vital to build a more practical black-box threat model to overcome this limitation and evaluate the vulnerability of deployed models. In this paper, with only the knowledge of the ImageNet domain, we propose a Beyond ImageNet Attack (BIA) to investigate the transferability towards black-box domains (unknown classification tasks). Specifically, we leverage a generative model to learn the adversarial function for disrupting low-level features of input images. Based on this framework, we further propose two variants to narrow the gap between the source and target domains from the data and model perspectives, respectively. Extensive experiments on coarse-grained and fine-grained domains demonstrate the effectiveness of our proposed methods. Notably, our methods outperform state-of-theart approaches by up to $7 . 7 1 \%$ (towards coarse-grained domains) and $2 5 . 9 1 \%$ (towards fine-grained domains) on average. Our code is available at https: //github.com/Alibaba-AAIG/Beyond-ImageNet-Attack.
+
+# 1 INTRODUCTION
+
+Deep neural networks (DNNs) have achieved remarkable success in the image classification task in recent years. Nonetheless, advances in the field of adversarial machine learning (Szegedy et al., 2014; Goodfellow et al., 2015; Zhang et al., 2022) make DNNs no longer reliable. By adding a well-designed perturbation on a benign image (a.k.a adversarial attack), the resulting adversarial examples can easily fool state-of-the-art DNNs. To make the matter worse, the adversarial attack technique can even be applied in the physical world (Sharif et al., 2016; Kurakin et al., 2017a; Xu et al., 2020; Duan et al., 2021), which inevitably raises concerns about the stability of deployed models. Therefore, exposing as many “blind spots” of DNNs as possible is a top priority.
+
+Generally, deployed models are mainly challenged with two threat models: white-box and blackbox. For white-box threat model (Kurakin et al., 2017b; Moosavi-Dezfooli et al., 2016; Carlini & Wagner, 2017; Shi et al., 2019; Liu et al., 2022), the attacker can obtain complete knowledge of the target model, such as the gradient for any input. However, deployed models are usually opaque to unauthorized users. In this scenario, prior black-box works (Poursaeed et al., 2018; Dong et al., 2018; Xie et al., 2019; Inkawhich et al., 2020; Gao et al., 2020b; Wang et al., 2021) mostly assume that the source data for training the target model is available and mainly explore the cross-model transferability among models trained in the same data distribution. Specifically, perturbations are crafted via accessible white-box model (a.k.a substitute model), and resulting adversarial examples sometimes can fool other black-box models as well. Yet, these works still ignore a pivotal issue: A model owner is unlikely to leak the relevant information of the deployed model. To overcome this limitation, query-based black-box attacks (Papernot et al., 2016; Brendel et al., 2018; Chen et al., 2020; Li et al., 2021) are proposed, which adjust adversarial examples just according to the output of the target model. However, the resource-intensive query budget is extremely costly and inevitably alerts the model owner.
+
+Table 1: A comparison of datasets from different domains.   
+
+<table><tr><td>Dataset</td><td>Resolution</td><td>Type</td><td>Test size</td><td>Classes</td></tr><tr><td>ImageNet (Russakovsky et al., 2015)</td><td>224×224</td><td>-</td><td>50,000</td><td>1,000</td></tr><tr><td>CIFAR-10 (Krizhevsky, 2009)</td><td>32×32</td><td>coarse-grained</td><td>10.000</td><td>10</td></tr><tr><td>CIFAR-100 (Krizhevsky,2009)</td><td>32×32</td><td>coarse-grained</td><td>10.000</td><td>100</td></tr><tr><td>STL-10 (Coates et al., 2011)</td><td>96×96</td><td>coarse-grained</td><td>8.000</td><td>10</td></tr><tr><td>SVHN (Netzer et al., 2011)</td><td>32×32</td><td>coarse-grained</td><td>26.032</td><td>10</td></tr><tr><td>CUB-200-2011 (Wah et al.,2011)</td><td>448×448</td><td>fine-grained</td><td>5,740</td><td>200</td></tr><tr><td>Stanford Cars (Krause etal., 2013)</td><td>448×448</td><td>fine-grained</td><td>8.041</td><td>196</td></tr><tr><td>FGVC Aircraft (Maji et al., 2013)</td><td>448×448</td><td>fine-grained</td><td>3,333</td><td>100</td></tr></table>
+
+Therefore, we need a more “practical” black-box threat model to address this concern, i.e., without any clue about the training data distribution as well as the pre-trained model based on it, and even querying is forbidden. Intuitively, this threat model is more challenging to build for attackers and more threatening to model owners. To the best of our knowledge, a recent work called CDA (Naseer et al., 2019) is the first to attempt such an attack. Specifically, it learns a transferable adversarial function via a generator network against a different domain (training data and pre-trained model are all from ChestX-ray (Wang et al., 2017) domain). During inference, it directly crafts adversarial examples for benign ImageNet images to fool target ImageNet pre-trained models. However, its cross-domain transfer strength is still moderate. Besides, relying on small-scale datasets to train a generator may limit the generalization of the threat model.
+
+Considering that ImageNet is a large-scale dataset containing most of common categories in real life and there are various off-the-shelf pre-trained models, one can easily dig out much useful information to build a strong threat model. Therefore, in this paper, solely relying on the knowledge of the ImageNet domain, we introduce an effective Beyond ImageNet Attack (BIA) framework to enhance the cross-domain transferability of adversarial examples. To reflect the applicability of our approach, we consider eight different image classification tasks (listed in Table 1). Figure 1 illustrates an overview of our method. Particularly, we learn a flexible generator network $\mathcal { G } _ { \theta }$ against ImageNet domain. Instead of optimizing the domain-specific loss function like CDA, our method focuses on disrupting low-level features following previous literature to ensure the good transferability of our BIA. Furthermore, we propose two variants based on the vanilla BIA to narrow the gap between source and target domains. Specifically, from the data perspective, we propose a random normalization $( \mathcal { R N } )$ module to simulate different data distributions; from the model perspective, we propose a domain-agnostic attention $( \mathcal { D A } )$ module to capture essential features for perturbing. In the inference phase, our $\mathcal { G } _ { \theta }$ accepts images of any domain as the input and crafts adversarial examples with one forward propagation. Extensive experiments demonstrate the effectiveness of our proposed methods. Towards the coarse-grained and fine-grained domains, we can outperform state-of-the-art approaches by up to $7 . 7 1 \%$ and $2 5 . 9 1 \%$ on average, respectively. Besides, our methods can also enhance the cross-model transferability in the source domain.
+
+# 2 RELATED WORKS
+
+Iterative Optimization Approaches. Under the black-box threat model, iterative attack methods are a popular branch, which usually adopt domain-specific loss or intermediate feature loss to craft adversarial examples. For the former, Madry et al. (2018) extend Goodfellow et al. (2015) to perform projected gradient descent from randomly chosen starting points inside $\epsilon$ -ball. Dong et al. (2018) introduce momentum term to stable the update direction. Xie et al. (2019) apply random transformations of the input at each iteration, thus mitigating overfitting. Gao et al. (2020a) propose patch-wise perturbation to better cover the discriminative region. Wu et al. (2020a) explore the security weakness of skip connections (He et al., 2016; Huang et al., 2017) to boost attacks.
+
+![](images/8121e455617a649017241861a0fbc7220d54b3c9c76dd54682286770fd75431c.jpg)  
+Figure 1: Our proposed generator framework aims to decrease the cosine similarity of feature between benign image $\scriptstyle { \mathbf { { \mathbf { x } } } } _ { s }$ and adversarial example $ { \boldsymbol { { x } } } _ { s } ^ { \prime }$ during the training phase. Training data and substitute model are all from the ImageNet domain. $\mathcal { C }$ module is applied to constrain $ { \boldsymbol { { x } } } _ { s } ^ { \prime }$ in the $\ell _ { \infty }$ -ball of $\mathbf { \Delta } _ { \mathbf { x } _ { s } }$ . $\mathcal { R N }$ and $\mathcal { D A }$ are optional, which can further improve the transferability.
+
+Different from the methods mentioned above, intermediate feature-based methods focus on disrupting low-level features. For example, Zhou et al. (2018) maximize the Euclidean distance between the source image and target image in feature space and introduce regularization on perturbations to reduce variations. Inkawhich et al. (2019) make the source image close to the target image in feature space. Lu et al. (2020) propose a dispersion reduction attack to make the low-level features featureless. Naseer et al. (2020) design a self-supervised perturbation mechanism for enabling a transferable defense approach. Wu et al. (2020b) compute model attention over extracted features to regularize the search of adversarial examples.
+
+Generator-oriented Approaches. Compared with iterative optimization approaches, generatororiented attacks are more efficient (i.e., only need one inference) to generate adversarial examples. In this branch, Baluja & Fischer (2017) propose an adversarial transformation network to modify the output of the classifier given the original input. Poursaeed et al. (2018) present trainable deep neural networks for producing both image-agnostic and image-dependent perturbations. Naseer et al. (2019) leverage datasets from other domain instead of ImageNet to train generator networks against pre-trained ImageNet models, and inference is performed on ImageNet domain with the aim of fooling black-box ImageNet model. They also attempt a practical black-box threat model (from ChestX-ray to ImageNet), and the attack success rate can outperform the result of Gaussian noise.
+
+# 3 TRANSFERABLE ADVERSARIAL EXAMPLES BEYOND IMAGENET
+
+# 3.1 PROBLEM FORMULATION
+
+Given a target deep learning classifier $f _ { t } ( \cdot )$ trained in a specific data distribution $\chi _ { t }$ , we aim to craft a human-imperceptible perturbation for the benign image $\mathbf { \mathcal { x } } _ { t } ~ \sim ~ \mathrm { \mathcal { \chi } } _ { t }$ from the target domain with the only available knowledge of source ImageNet domain (including pre-trained model $f _ { s } ( \cdot )$ and data distribution $\chi _ { s }$ ). Formally, suppose we have a threat model $\mathcal { M } _ { \theta ^ { * } }$ whose parameter $\theta ^ { * }$ is solely derived from the source domain, our goal is to craft adversarial examples for $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { t } }$ from target domain so that they can fool the $f _ { t } ( \cdot )$ successfully:
+
+$$
+f _ { t } ( \mathcal { M } _ { \theta ^ { * } } ( \pmb { x } _ { t } ) ) \neq f _ { t } ( \pmb { x } _ { t } ) \quad s . t . | | \mathcal { M } _ { \theta ^ { * } } ( \pmb { x } _ { t } ) - \pmb { x } _ { t } | | _ { \infty } \leq \epsilon ,
+$$
+
+where $\epsilon$ is the maximum perturbation to ensure $\mathbf { \Delta } \mathbf { x } _ { t }$ is minimally changed. Intuitively, crafting adversarial examples for the black-box domain is very challenging. As shown in Table 1 and Figure 6 of Appendix, images from different domain vary greatly.
+
+# 3.2 PRELIMINARY
+
+Iterative/Single-step optimization methods (Goodfellow et al., 2015; Madry et al., 2018; Zhao et al., 2020; Gao et al., 2021; Mao et al., 2021; Li et al., 2021) and generator-oriented methods (Baluja & Fischer, 2017; Poursaeed et al., 2018; Naseer et al., 2019) are two popular branches for building the threat model. Since the attacker has the large-scale ImageNet training set at hand, there is no reason not to take full advantage of them. Therefore, in this paper, we adopt the generator-oriented framework which learns a transferable adversarial function via a generative model $\mathcal { G } _ { \theta }$ . Given that the threat model aims at crafting transferable adversarial examples for black-box domains, relying on the last layer with domain-specific loss functions (e.g., relativistic cross-entropy loss adopted by Naseer et al. (2019)) is less effective since this might lead to overfitting to source domain. In contrast, the intermediate layers of the DNN presumably extract general features (Yosinski et al., 2014) which may share across different models. Hence, as a baseline for the new black-domain attack problem, our Beyond ImageNet Attack (BIA) turns to destroy the low-level features of the substitute model at a specific layer $L$ to generate transferable adversarial examples according to existing literature (Yosinski et al., 2014; Zhou et al., 2018; Inkawhich et al., 2019).
+
+![](images/01a8e12d393b8450d7e888a6a7666abc0cb6492505ac5a19f70963ecd4f17185.jpg)  
+Figure 2: Left: The data distribution (i.e., mean and standard deviation) for datasets from different domains. The result is the average over the three channels. Right: Two intermediate feature maps (Maxpool.3) of VGG-16 (Simonyan & Zisserman, 2015) (trained in ImageNet domain) for the input image from CUB-200-2011 (Wah et al., 2011).
+
+As illustrated in Figure $1 , { \mathcal { G } } _ { \theta }$ is learned to decrease the cosine similarity between adversarial example $ { \boldsymbol { { x } } } _ { s } ^ { \prime }$ and benign image $\pmb { x _ { s } } \in \mathbb { R } ^ { N \times H _ { s } \times W _ { s } }$ (sampled from $\chi _ { s }$ ) to make the feature featureless:
+
+$$
+\theta ^ { * } = \underset { \theta } { \arg \operatorname* { m i n } } \mathcal { L } _ { c o s } ( f _ { s } ^ { L } ( \pmb { x } _ { s } ^ { \prime } ) , f _ { s } ^ { L } ( \pmb { x } _ { s } ) ) .
+$$
+
+In the inference phase, our generator $\mathcal { G } _ { \theta ^ { * } }$ can directly craft adversarial examples for input images $\pmb { x _ { t } } \in \mathbb { R } ^ { N \times H _ { t } \times W _ { t } ^ { \pm } }$ from the target domain:
+
+$$
+\begin{array} { r } { \pmb { x } _ { t } ^ { \prime } = \operatorname* { m i n } ( \pmb { x } _ { t } + \epsilon , \operatorname* { m a x } ( \mathcal { G } _ { \theta ^ { * } } ( \pmb { x } _ { t } ) , \pmb { x } _ { t } - \epsilon ) . } \end{array}
+$$
+
+The resulting adversarial examples $ { \boldsymbol { { x } } } _ { t } ^ { \prime }$ are depicted in Figure 8 of Appendix. Compared with CDA, our BIA is more effective in both source (white-box) and target (black-box) domains. Yet, as shown in Figure 2, crafting more transferable adversarial examples still has some challenges:
+
+• Data Perspective: The distribution (i.e., mean and standard deviation) of source domain is largely different from the target domain. For example, the standard deviation of ImageNet is about twice that of SVHN. • Model Perspective: Although some feature map of $f _ { s } ^ { L } ( \cdot )$ can capture the object $( \in \chi _ { t } )$ for feature representation (e.g., the first feature map in Figure 2), there are also some feature maps that are significantly biased (e.g., the second feature map in Figure 2).
+
+To alleviate the concern of generating poor transferable adversarial examples that may arise from the above limitations, we propose two variants, equipped with random normalization $( \mathcal { R N } )$ module or domain-agnostic attention $( \mathcal { D A } )$ module, respectively.
+
+# 3.3 RANDOM NORMALIZATION MODULE
+
+Generally, DNNs (Simonyan & Zisserman, 2015; He et al., 2016; Huang et al., 2017) are usually equipped with normalization for input images1 so that they can be modeled as samples from the standard normal distribution. However, as illustrated in Figure 2 (left), the distribution of dataset from the different domain can vary dramatically. Thus, training against a specific domain may limit the generalization of the resulting $\mathcal { G } _ { \theta ^ { * } }$ . Besides, the commonly used strategy of label-preserving data augmentation (Krizhevsky et al., 2012; Simonyan & Zisserman, 2015) is less effective because it has little effect on changing the distribution of the inputs (more details are shown in Appendix A.3).
+
+To overcome this limitation, fusing knowledge from different domains might be helpful. As shown in Table 3 of Naseer et al. (2019), using training data from other domains against the pre-trained model in the source domain usually enhances the transferability of adversarial examples towards the target domain. However, this setup is not feasible because the available knowledge for a more practical threat model may be limited, i.e., restricted to one domain. Therefore, we instead propose a random normalization $( \mathcal { R N } )$ module to simulate different data distribution in the training phase:
+
+$$
+{ \mathcal R N } ( { \pmb x } _ { s } ) = \pmb { \sigma } \cdot \frac { { \pmb x } _ { s } - { \pmb \mu } ^ { \prime } } { \sigma ^ { \prime } } + { \pmb \mu } ,
+$$
+
+where $\sigma$ and $\pmb { \mu }$ are default standard deviation and mean vectors for ImageNet, and $\mu ^ { \prime } \sim$ $\mathcal { N } ( \mu _ { m e a n } ^ { \prime } , \mu _ { s t d } ^ { \prime } )$ and $\sigma ^ { \prime } \sim \mathcal { N } ( \sigma _ { m e a n } ^ { \prime } , \sigma _ { s t d } ^ { \prime } )$ are two random scales2 sampled from Gaussian distribution. Combined with $\mathcal { R N }$ , and the object function can be expressed as:
+
+$$
+\theta ^ { * } = \underset { \theta } { \arg \operatorname* { m i n } } \mathcal { L } _ { c o s } ( f _ { s } ^ { L } ( \mathcal { R N } ( \pmb { x } _ { s } ^ { \prime } ) ) , f _ { s } ^ { L } ( \mathcal { R N } ( \pmb { x } _ { s } ) ) ) .
+$$
+
+# 3.4 DOMAIN-AGNOSTIC ATTENTION MODULE
+
+Unlike the random normalization module, the domain-agnostic attention module aims to narrow the domain gap from the model perspective. Our inspiration is from prior works (Hansen & Salamon, 1990; Caruana et al., 2004; Dong et al., 2018), which demonstrate that the ensemble strategy can avoid getting trapped in the local optimum and improve performance. Since there are many feature maps at layer $L$ and each of them can model the input, i.e., extracts the features, we can also integrate them to produce a more robust feature representation $\mathcal { A } ^ { L }$ , thus mitigating the impact of several biased feature maps, e.g., the second feature map of Figure 2. Specifically, we apply cross-channel average pooling to the feature maps at layer $L$ :
+
+$$
+\mathbf { \mathcal { A } } ^ { L } = \frac { | \sum _ { i = 0 } ^ { C } [ f _ { s } ^ { L } ( \pmb { x _ { s } } ) ] _ { i } | } { C } ,
+$$
+
+where $C$ is channel number of $f _ { s } ^ { L } ( { \pmb x } _ { s } )$
+
+As depicted in Figure 3, even if our source model is not trained in the target domain, the robust feature representation is still able to capture the essential feature of object very well. Surprisingly, it is even similar to the one that derived from a completely different target model. Therefore, this robust feature representation can serve as a domain-agnostic attention $( \mathcal { D A } )$ to enhance the cross-domain transferability
+
+![](images/017cda7c2d8d0c9cb2d8fcde5c6da85a3ebbab2a3f5a58b40ec4e00c88081cc2.jpg)  
+Figure 3: Left: A benign image from Stanford Cars (Krause et al., 2013). Middle $\pmb { \& }$ Right: We apply cross-channel average pooling to the intermediate feature maps (M axpool.3) of VGG-16 and (Conv3 8) of DCL (Chen et al., 2019) with backbone Res-50.
+
+of adversarial examples. Specifically, in the training phase, we leverage $\mathcal { A } ^ { L }$ to assign weights for each pixel of feature maps at the same layer. The resulting object function can be written as:
+
+$$
+\theta ^ { * } = \underset { \theta } { \arg \operatorname* { m i n } } \mathcal { L } _ { c o s } ( \mathcal { A } ^ { L } \odot f _ { s } ^ { L } ( \boldsymbol { x } _ { s } ^ { \prime } ) , \mathcal { A } ^ { L } \odot f _ { s } ^ { L } ( \boldsymbol { x } _ { s } ) ) ,
+$$
+
+where $\odot$ is Hadamard product. After the training, even if the inputs are not from the source domain, our generator $\mathcal { G } _ { \theta ^ { * } }$ is supposed to own an ability to capture the essential feature to disrupt.
+
+# 4 EXPERIMENTS
+
+Source (white-box) Domain. Our training data is the large-scale ImageNet (Russakovsky et al., 2015) training set which includes about 1.2 million $2 2 4 \times 2 2 4 \times 3$ images. Generators are trained against four ImageNet pre-trained models including VGG-16, VGG-19 (Simonyan & Zisserman, 2015), ResNet152 (Res-152) (He et al., 2016) and DenseNet169 (Dense-169) (Huang et al., 2017). In this domain, we also consider three other models, i.e., DenseNet121 (Dense-121) (Huang et al.,
+
+2017), ResNet50 (Res-50) (He et al., 2016) and Inception-v3 (Inc-v3)3 (Szegedy et al., 2016), to analyze the cross-model transferability. All models are available in the Torchvision library4.
+
+Target (black-box) Domain. Generally, the image classification tasks can be divided into coarsegrained and fine-grained tasks in terms of label granularity (Touvron et al., 2021). Thus, in addition to ImageNet (white-box domain), we consider seven other black-box domains (shown in Table 1) including four coarse-grained (CIFAR-10, CIFAR-100 (Krizhevsky, 2009), STL-10 (Coates et al., 2011) and SVHN (Netzer et al., 2011)) and three fine-grained (CUB-200-2011 (Wah et al., 2011), Stanford Cars (Krause et al., 2013) and FGVC Aircraft (Maji et al., 2013)) classification tasks. For the fine-grained classification, we use DCL framework (Chen et al., 2019) with three different backbones: ResNet50 (Res-50) (He et al., 2016), SENet154 and SE-ResNet101 (SE-Res101) (Hu et al., 2018). The pre-trained models for the coarse-grained classification are from Github5.
+
+Implementation Details. Our generator $\mathcal { G } _ { \theta }$ adopts the same architecture as (Naseer et al., 2019), which is a composite of downsampling, residual (He et al., 2016) and upsampling blocks (more details can be found in Figure 7 of Appendix). The output size of $\mathcal { G } _ { \theta }$ is equal to the input size. For CDA and our methods, we use Adam optimizer (Kingma & Ba, 2015) with a learning rate of 2e-4 and the exponential decay rate for first and second moments is set to 0.5 and 0.999, respectively. All generators are trained for one epoch with the batch size 16. For the layer $L$ , we attack the output of M axpool.3 for VGG-16 and VGG-19, the output of Conv3 8 for Res-152 and the output of DenseBlock.2 for Dense-169 (ablation study can be found in Appendix A.1). For brevity, we only refer the output of a specific layer/block using its layer/block name. For our $\mathcal { R N }$ module, we set $\mu ^ { \prime } \sim \mathcal { N } ( 0 . 5 \bar { 0 } , 0 . 0 8 )$ and $\sigma ^ { \prime } \sim \dot { \mathcal { N } } ( 0 . 7 5 , 0 . 0 8 )$ , and the ablation study is shown in Appendix A.2.
+
+Competitors. We compare our proposed methods with projected gradient descent (PGD) (Madry et al., 2018), diverse inputs method (DIM) (Dong et al., 2018; Xie et al., 2019), dispersion reduction (DR) (Lu et al., 2020), self-supervised perturbation (SSP) (Naseer et al., 2020) and cross-domain attack (CDA) (Naseer et al., 2019). The maximum perturbation $\varepsilon$ is set to 10. Follow Lu et al. (2020), we set the step size $\alpha = 4$ and the number of iterations $T = 1 0 0$ for all iterative methods. For DIM, we set the default decay factor $\mu = 1 . 0$ and the transformation probability $p = 0 . 7$ . The Gaussian smoothing (gs) for CDA is applied by $3 \times 3$ Gaussian kernel.
+
+Evaluation Metrics. We use the top-1 accuracy on the whole test set (test size is shown in Table 1) after attacking to evaluate the performance of different methods. We also report standard deviation across multiple random runs in Appendix A.7.
+
+# 4.1 TRANSFERABILITY COMPARISONS
+
+In this section, we first conduct experiments for the black-box domain in Section 4.1.1 (coarsegrain) and Section 4.1.2 (fine-grain), then we report the results for the white-box (source) domain in Section 4.1.3. For the discussion of generator mechanism, changing source domain and ensemblemodel attacks, we leave them in Appendix A.4, Appendix A.5 and Appendix A.6, respectively.
+
+# 4.1.1 RESULTS ON COARSE-GRAINED DOMAIN
+
+In this section, we craft transferable adversarial examples for coarse-grained classification tasks. The results are shown in Table 2, where we leverage four ImageNet pre-trained models, including VGG-16, VGG-19, Res-152 and Dense-169, to train generators, respectively.
+
+From Table 2, a first glance shows that our proposed methods consistently surpass state-of-the-art approaches. For example, if the substitute model is VGG-16, the most effective CDA remains a top-1 accuracy of $6 6 . 4 1 \%$ for CIFAR-10 after attacking, while our vanilla BIA can effectively bring down it to $5 7 . 3 8 \%$ and $\mathcal { D A }$ variant can further drop the top-1 accuracy to $5 5 . 1 6 \%$ . Among all tasks, the STL-10 and SVHN domains are the most difficult to attack, and the performance gap among existing attacks is moderate. Nonetheless, we can significantly enhance the transferability with the help of our $\mathcal { R N }$ variant in these domains. Notably, if the substitute model is Res-152, $\mathcal { R } \dot { \mathcal { N } }$ variant can further decrease the top-1 accuracy from $8 9 . 4 6 \%$ (vanilla BIA) to $8 5 . 7 9 \%$ on SVHN. Compared with state-of-the-art CDA on all domains, $\mathcal { R N }$ variant significantly outperforms it by $7 . 7 1 \%$ on average. This demonstrates that our proposed $\mathcal { R N }$ module is effective in coping with different distributions of inputs, thus improving the generalization of the resulting generator.
+
+Table 2: Transferability comparisons on four coarse-grained classification tasks. Here we report the top-1 accuracy after attacking (the lower, the better). The generator $\mathcal { G } _ { \theta }$ is trained in the ImageNet domain, and adversarial examples are within the perturbation budget of $\ell _ { \infty } \leq 1 0$ .   
+
+<table><tr><td>Model</td><td>Attacks Clean</td><td>CIFAR-10 93.78</td><td>CIFAR-100 74.27</td><td>STL-10 77.59</td><td>SVHN 96.03</td><td>AVG. 85.42</td><td>Model</td><td>Attacks Clean</td><td>CIFAR-10 93.78</td><td>CIFAR-100 74.27</td><td>STL-10 77.59</td><td>SVHN 96.03</td><td>AVG. 85.42</td></tr><tr><td rowspan="9">91-99A</td><td>PGD</td><td>79.63</td><td>48.02</td><td>74.32</td><td>94.66</td><td>74.16</td><td></td><td>PGD DIM</td><td>86.17</td><td>56.38</td><td>74.51</td><td>93.94</td><td>77.75</td></tr><tr><td>DIM</td><td>77.16</td><td>44.75</td><td>72.74</td><td>91.53</td><td>71.55</td><td></td><td></td><td>80.50</td><td>48.03</td><td>71.2</td><td>90.87</td><td>72.65</td></tr><tr><td>DR</td><td>72.49</td><td>39.04</td><td>72.56</td><td>93.27</td><td>69.34</td><td></td><td>DR</td><td>78.86</td><td>48.62</td><td>71.66</td><td>93.26</td><td>73.10</td></tr><tr><td>SSP</td><td>68.54</td><td>33.63</td><td>72.77</td><td>93.98</td><td>67.23</td><td></td><td>SSP</td><td>75.54</td><td>42.38</td><td>72.66</td><td>92.63</td><td>70.80</td></tr><tr><td>CDA</td><td>66.41</td><td>32.37</td><td>72.91</td><td>92.17</td><td>65.97</td><td>P2s3152</td><td>CDA</td><td>66.47</td><td>39.30</td><td>69.81</td><td>88.09</td><td>65.92</td></tr><tr><td>CDA+gs</td><td>86.70</td><td>59.43</td><td>73.38</td><td>91.61</td><td>77.78</td><td></td><td>CDA+gs</td><td>85.61</td><td>57.27</td><td>73.06</td><td>90.34</td><td>76.57</td></tr><tr><td>BIA (Ours)</td><td>57.38</td><td>22.47</td><td>69.45</td><td>90.44</td><td>59.94</td><td></td><td>BIA(Ours)</td><td>65.49</td><td>33.48</td><td>69.91</td><td>89.46</td><td>64.59</td></tr><tr><td>BIA+DA(Ours)</td><td>55.16</td><td>21.71</td><td>70.00</td><td>91.76</td><td>59.66</td><td></td><td>BIA+DA(Ours)</td><td>65.34</td><td>32.68</td><td>69.65</td><td>91.38</td><td>64.76</td></tr><tr><td>BIA+RN(Ours)</td><td>52.81</td><td>20.82</td><td>67.55</td><td>88.03</td><td>57.30</td><td></td><td>BIA+RN(Ours)</td><td>61.23</td><td>32.84</td><td>68.04</td><td>85.79</td><td>61.98</td></tr><tr><td rowspan="9">6-D5A</td><td>PGD</td><td>79.15</td><td>47.73</td><td>74.71</td><td>94.86</td><td>74.11</td><td></td><td>PGD</td><td>84.55</td><td>54.29</td><td>74.55</td><td>93.83</td><td>76.81</td></tr><tr><td>DIM</td><td>77.54</td><td></td><td></td><td>91.68</td><td>71.50</td><td></td><td>DIM</td><td>80.89</td><td></td><td></td><td></td><td>73.02</td></tr><tr><td>DR</td><td>70.72</td><td>43.81</td><td>72.96</td><td>93.73</td><td>68.51</td><td></td><td>DR</td><td>78.24</td><td>49.06 48.67</td><td>72.64</td><td>89.47 93.2</td><td>72.72</td></tr><tr><td>SSP</td><td>70.46</td><td>37.59 35.28</td><td>71.98 73.21</td><td>93.67</td><td>68.16</td><td>GD-sse50</td><td>SSP</td><td>77.13</td><td>42.18</td><td>70.75</td><td>91.64</td><td>70.87</td></tr><tr><td>CDA</td><td>81.60</td><td>51.53</td><td>71.43</td><td>92.64</td><td>74.30</td><td></td><td>CDA</td><td>67.75</td><td>35.03</td><td>72.53 69.00</td><td>88.76</td><td>65.14</td></tr><tr><td>CDA+gs</td><td>88.55</td><td>61.90</td><td>73.64</td><td>92.18</td><td>79.07</td><td></td><td>CDA+gs</td><td>85.01</td><td>54.71</td><td>72.61</td><td>88.69</td><td>75.26</td></tr><tr><td>BIA (Ours)</td><td>57.88</td><td>23.12</td><td></td><td></td><td>59.93</td><td></td><td>BIA (Ours)</td><td>72.02</td><td></td><td></td><td></td><td></td></tr><tr><td>BIA+DA(Ours)</td><td>57.26</td><td>23.04</td><td>69.84 70.16</td><td>88.89 90.08</td><td>60.14</td><td></td><td>BIA+DA(Ours)</td><td>71.69</td><td>38.99 38.95</td><td>69.80</td><td>86.12</td><td>66.73</td></tr><tr><td>BIA+RN (Ours)</td><td>54.47</td><td>22.61</td><td>68.23</td><td>88.08</td><td>58.35</td><td></td><td>BIA+RN (Ours)</td><td>66.67</td><td>34.41</td><td>70.60 68.79</td><td>88.02 81.54</td><td>67.32 62.85</td></tr></table>
+
+Table 3: Transferability comparisons on three fine-grained classification tasks. Here we report the top-1 accuracy after attacking (the lower, the better). The generator $\mathcal { G } _ { \theta }$ is trained in ImageNet domain and adversarial examples are within the perturbation budget of $\ell _ { \infty } \leq 1 0$ .   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Attacks</td><td colspan="3">CUB-200-2011</td><td colspan="3">Stanford Cars</td><td colspan="3">FGVC Aircraft</td><td rowspan="2">AVG.</td></tr><tr><td>Res-50</td><td>SENet154</td><td>SE-Res101</td><td>Res-50</td><td>SENet154</td><td>SE-Res101</td><td>Res-50</td><td></td><td>SENet154SE-Res101</td></tr><tr><td rowspan="9">9I-55A</td><td>Clean</td><td>87.35</td><td>86.81</td><td>86.56</td><td>94.35</td><td>93.36</td><td>92.97</td><td>92.23</td><td>92.08</td><td>91.90</td><td>90.85</td></tr><tr><td>PGD</td><td>80.65</td><td>79.58</td><td>80.69</td><td>87.45</td><td>89.04</td><td>90.30</td><td>84.88</td><td>83.92</td><td>82.15</td><td>84.30</td></tr><tr><td>DIM</td><td>70.02</td><td>62.86</td><td>70.57</td><td>74.72</td><td>78.10</td><td>84.33</td><td>73.54</td><td>66.88</td><td>62.38</td><td>71.49</td></tr><tr><td>DR</td><td>81.08</td><td>82.05</td><td>82.52</td><td>90.82</td><td>90.59</td><td>91.12</td><td>84.97</td><td>87.55</td><td>85.54</td><td>86.25</td></tr><tr><td>SSP</td><td>62.27</td><td>60.44</td><td>71.52</td><td>58.02</td><td>75.71</td><td>83.02</td><td>54.91</td><td>68.74</td><td>63.79</td><td>66.49</td></tr><tr><td>CDA</td><td>69.69 70.19</td><td>62.51</td><td>71.00</td><td>75.94</td><td>72.45</td><td>84.64</td><td>71.53</td><td>58.33</td><td>63.39</td><td>69.94</td></tr><tr><td>CDA+gs</td><td></td><td>63.19</td><td>68.92</td><td>85.03</td><td>79.52</td><td>83.52</td><td>78.55</td><td>65.62</td><td>68.38</td><td>73.66</td></tr><tr><td>BIA (Ours)</td><td>32.74 25.00</td><td>52.99</td><td>58.04</td><td>39.61</td><td>69.90</td><td>70.17</td><td>28.92</td><td>60.31</td><td>46.92</td><td>51.07</td></tr><tr><td>BIA+DA(Ours) BIA+RN(Ours)</td><td>26.13</td><td>40.27 46.15</td><td>53.24 55.07</td><td>22.24 20.61</td><td>59.48 62.64</td><td>61.52 63.38</td><td>15.36 16.50</td><td>47.91 52.54</td><td>40.83 45.48</td><td>40.65 43.17</td></tr><tr><td rowspan="9">6--555</td><td>PGD</td><td>80.98</td><td>79.00</td><td>80.60</td><td>87.54</td><td>88.87</td><td>90.56</td><td>84.70</td><td>84.01</td><td>83.35</td><td>84.40</td></tr><tr><td>DIM</td><td>69.93</td><td>61.60</td><td>70.90</td><td>75.02</td><td>78.55</td><td>84.63</td><td>74.59</td><td>67.69</td><td>65.26</td><td>72.02</td></tr><tr><td>DR</td><td>80.83</td><td>81.57</td><td>81.95</td><td>91.00</td><td>90.23</td><td>91.15</td><td>84.43</td><td>85.96</td><td>84.57</td><td>85.74</td></tr><tr><td>SSP</td><td>62.94</td><td>58.34</td><td>70.45</td><td>61.90</td><td>76.27</td><td>83.77</td><td>58.78</td><td>69.52</td><td>66.88</td><td>67.65</td></tr><tr><td>CDA</td><td>59.48</td><td>61.08</td><td>68.50</td><td>58.53</td><td>70.70</td><td>80.70</td><td>59.26</td><td>52.24</td><td>62.26</td><td>63.64</td></tr><tr><td>CDA+gs</td><td>67.88</td><td>59.42</td><td>67.57</td><td>82.83</td><td>78.61</td><td>82.64</td><td>79.36</td><td>65.89</td><td>68.35</td><td>72.51</td></tr><tr><td>BIA (Ours)</td><td>48.90</td><td>52.33</td><td>56.47</td><td>66.34</td><td>72.45</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>BIA+DA(Ours)</td><td>27.46</td><td>37.61</td><td>50.14</td><td>35.27</td><td>61.40</td><td>75.08 64.41</td><td>50.95 17.97</td><td>54.04 45.81</td><td>51.79 44.01</td><td>58.71</td></tr><tr><td>BIA+RN(Ours)</td><td>31.77</td><td>43.41</td><td>51.09</td><td>42.81</td><td>68.90</td><td>66.27</td><td>27.75</td><td>52.48</td><td>45.57</td><td>42.68 47.78</td></tr><tr><td rowspan="8">P1s-152</td><td>PGD</td><td>73.21</td><td>75.89</td><td>76.11</td><td>83.99</td><td>86.89</td><td>88.24</td><td>79.00</td><td>79.30</td><td>75.64</td><td>79.81</td></tr><tr><td>DIM</td><td>56.30</td><td>59.35</td><td>63.36</td><td>67.88</td><td>76.37</td><td>79.77</td><td>64.21</td><td>62.95</td><td>54.49</td><td>64.96</td></tr><tr><td>DR</td><td>77.58</td><td>82.07</td><td>80.60</td><td>87.96</td><td>90.11</td><td>90.67</td><td>77.89</td><td>82.27</td><td>80.08</td><td>83.25</td></tr><tr><td>SSP</td><td>47.64</td><td>66.17</td><td>67.90</td><td>53.29</td><td>79.09</td><td>83.45</td><td>58.35</td><td>73.36</td><td>69.34</td><td>66.51</td></tr><tr><td>CDA</td><td>45.15</td><td>53.69</td><td>52.86</td><td>57.72</td><td>63.09</td><td>73.05</td><td>64.87</td><td>46.74</td><td>59.11</td><td>57.36</td></tr><tr><td>CDA+gs</td><td>59.32</td><td>64.24</td><td>60.08</td><td>81.15</td><td>82.91</td><td>82.56</td><td>75.52</td><td>73.72</td><td>66.58</td><td>71.79</td></tr><tr><td>BIA(Ours)</td><td>43.55</td><td>49.50</td><td>55.54</td><td>31.65</td><td>54.12</td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>BIA+DA(Ours)</td><td>25.80</td><td>39.71</td><td>52.83</td><td>33.43</td><td>52.41</td><td>67.21 68.03</td><td>38.49 27.51</td><td>32.46 27.42</td><td>51.19 47.28</td><td>47.08 41.60</td></tr><tr><td rowspan="8">GDr-ese5g</td><td>BIA+RN(Ours)</td><td>23.54</td><td>40.13</td><td>51.36</td><td>12.39</td><td>47.92</td><td>60.59</td><td>32.34</td><td>32.85</td><td>46.89</td><td>38.67</td></tr><tr><td>PGD</td><td>79.29</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>DIM</td><td>63.17</td><td>81.14 62.01</td><td>79.74 65.96</td><td>87.66 72.88</td><td>90.13</td><td>89.80</td><td>83.23</td><td>84.31</td><td>81.24</td><td>84.06</td></tr><tr><td>DR</td><td>74.84</td><td>78.89</td><td>77.93</td><td>86.54</td><td>78.29 88.82</td><td>81.25 89.52</td><td>68.89 77.80</td><td>65.26 78.73</td><td>54.79 74.47</td><td>68.06 80.84</td></tr><tr><td>SSP</td><td>41.80</td><td>49.95</td><td>59.72</td><td>26.65</td><td>68.71</td><td>74.36</td><td>16.80</td><td>55.78</td><td>44.07</td><td>48.65</td></tr><tr><td>CDA</td><td>52.92</td><td>60.96</td><td>57.04</td><td>53.64</td><td>73.66</td><td>75.51</td><td>62.23</td><td>61.42</td><td>59.83</td><td>61.91</td></tr><tr><td>CDA+gs</td><td>60.86</td><td>61.34</td><td>60.10</td><td>74.95</td><td>76.35</td><td>78.86</td><td>72.94</td><td>68.68</td><td>64.66</td><td>68.75</td></tr><tr><td>BIA (Ours)</td><td>21.79</td><td>29.29</td><td>39.13</td><td>9.58</td><td>44.46</td><td>49.06</td><td>8.04</td><td>27.84</td><td>33.87</td><td>29.23</td></tr><tr><td></td><td>BIA+DA(Ours) 12.36</td></table>
+
+# 4.1.2 RESULTS ON FINE-GRAINED DOMAIN
+
+We also analyze the transferability of adversarial examples towards fine-grained classification tasks. For each domain, three black-box models with different backbones trained via the DCL framework are the target. The results are summarized in Table 3, where the leftmost column is the substitute model and the top row shows the target model.
+
+In this scenario, the performance gap between the existing state-of-the-art algorithms and our proposed methods is further enlarged. Remarkably, when attacking against Dense-169, even the vanilla BIA can drop the average top-1 accuracy to $2 9 . 2 3 \%$ , while $\mathrm { C D A + g s }$ , CDA, SSP, DR, DIM and PGD are still with the high average top-1 accuracy of $6 8 . 7 5 \%$ , $6 1 . 9 1 \%$ , $4 8 . 6 5 \%$ , $8 0 . 8 4 \%$ , $6 8 . 0 6 \%$ and $8 4 . 0 6 \%$ after attacking, respectively. Furthermore, by adding $\mathcal { D A }$ or $\mathcal { R N }$ modules in the training phase, the generator $\mathcal { G } _ { \theta ^ { * } }$ is capable of crafting more transferable adversarial examples. On average, our $\mathcal { R N }$ variant can reduce the top-1 accuracy from $4 6 . 5 2 \%$ (vanilla BIA) to $3 9 . 3 3 \%$ , and $\mathcal { D A }$ variant can further drop it to $3 6 . 4 2 \%$ , which remarkably outperforms SSP by $2 5 . 9 1 \%$ . This demonstrates our proposed $\mathcal { D A }$ module can effectively alleviate the bias caused by several feature maps, thus focusing on disrupting essential features.
+
+Table 4: Transferability comparisons on ImageNet (source domain). Here we report the top-1 accuracy after attacking (the lower, the better). The generator $\mathcal { G } _ { \theta }$ is trained in ImageNet domain (“\*” denotes white-box model) and adversarial examples are within the perturbation budget of $\ell _ { \infty } \leq 1 0$ .   
+
+<table><tr><td>Model</td><td>Attack Clean</td><td>VGG-16 70.14</td><td>Dense-169 75.75</td><td>VGG-19 70.95</td><td>Res-50 74.61</td><td>Res-152 77.34</td><td>Dense-121 74.22</td><td>Inc-v3 76.19</td><td>AVG. 74.17</td></tr><tr><td rowspan="9">VGG-16</td><td>PGD</td><td>2.49*</td><td>53.22</td><td>4.27</td><td>45.52</td><td>58.69</td><td>48.28</td><td>61.08</td><td>39.08</td></tr><tr><td>DIM</td><td>3.32*</td><td>22.72</td><td>3.39</td><td>19.13</td><td>33.03</td><td>18.50</td><td>30.05</td><td>18.59</td></tr><tr><td>DR</td><td>20.95*</td><td>67.91</td><td>43.59</td><td>64.90</td><td>70.00</td><td>64.73</td><td>69.22</td><td>57.33</td></tr><tr><td>SSP</td><td>0.95*</td><td>39.56</td><td>3.42</td><td>26.22</td><td>41.68</td><td>34.45</td><td>47.46</td><td>27.68</td></tr><tr><td>CDA</td><td>0.40*</td><td>42.67</td><td>0.77</td><td>36.27</td><td>51.05</td><td>38.89</td><td>54.02</td><td>32.01</td></tr><tr><td>CDA+gs</td><td>12.10*</td><td>57.09</td><td>20.48</td><td>51.87</td><td>60.83</td><td>52.21</td><td>55.12</td><td>44.24</td></tr><tr><td>BIA (Ours)</td><td>1.55*</td><td>32.35</td><td>3.61</td><td>25.36</td><td>42.98</td><td>26.97</td><td>41.20</td><td>24.86</td></tr><tr><td>BIA+DA(Ours)</td><td>1.04*</td><td>24.52</td><td>2.07</td><td>18.63</td><td>36.43</td><td>19.97</td><td>34.54</td><td>19.60</td></tr><tr><td>BIA+RN(Ours)</td><td>1.44*</td><td>25.96</td><td>2.58</td><td>16.52</td><td>31.80</td><td>18.25</td><td>28.54</td><td>17.87</td></tr><tr><td rowspan="9">Dense-169</td><td>PGD</td><td>38.51</td><td>5.03*</td><td>40.53</td><td>33.91</td><td>44.97</td><td>21.18</td><td>58.30</td><td>34.63</td></tr><tr><td>DIM</td><td>12.31</td><td>5.25*</td><td>13.20</td><td>8.98</td><td>12.93</td><td>5.91</td><td>21.44</td><td>11.43</td></tr><tr><td>DR</td><td>38.45</td><td>23.99*</td><td>41.59</td><td>50.19</td><td>58.70</td><td>49.95</td><td>63.70</td><td>46.65</td></tr><tr><td>SSP</td><td>11.53</td><td>1.32*</td><td>12.54</td><td>12.97</td><td>25.66</td><td>9.74</td><td>25.58</td><td>14.19</td></tr><tr><td>CDA</td><td>7.26</td><td>0.63*</td><td>7.91</td><td>6.46</td><td>15.56</td><td>5.13</td><td>43.78</td><td>12.39</td></tr><tr><td>CDA+gs</td><td>27.98</td><td>22.95*</td><td>28.56</td><td>31.52</td><td>43.67</td><td>31.66</td><td>49.18</td><td>33.65</td></tr><tr><td>BIA (Ours)</td><td>4.76</td><td>6.45*</td><td>7.15</td><td>6.97</td><td>13.83</td><td>6.60</td><td>38.58</td><td>12.05</td></tr><tr><td>BIA+DA(Ours)</td><td>3.17</td><td>3.32*</td><td>4.09</td><td>4.44</td><td>5.85</td><td>3.98</td><td>26.51</td><td>7.34</td></tr><tr><td>BIA+RN(Ours)</td><td>3.66</td><td>4.05*</td><td>5.23</td><td>6.91</td><td>13.25</td><td>4.21</td><td>14.24</td><td>7.36</td></tr></table>
+
+# 4.1.3 RESULTS ON SOURCE DOMAIN
+
+Although our proposed methods are mainly designed to improve the threat of adversarial examples towards black-box domains, they are also effective for enhancing the cross-model black-box transferability in the white-box domain. For example, by training against Dense-169, CDA still remains a top-1 accuracy of $4 3 . 7 8 \%$ on Inc-v3, while our BIA can achieve a relatively low top-1 accuracy of $3 8 . 5 8 \%$ on it. Besides, $\mathcal { R N }$ variant can further decrease the top-1 accuracy on Dense-169 (whitebox model) and Inc-v3 (black-box model) by $2 . 4 \%$ and $2 4 . 3 4 \%$ , respectively. This demonstrates that our proposed $\mathcal { R N }$ module is also able to avoid getting stuck in the local optimum of a specific model when training on a large-scale dataset. For $\mathcal { D A }$ variant, since the target domain and source domain are identical, it is naturally able to improve the transferability as well. As shown in Table 4, compared with vanilla BIA, $\mathcal { D A }$ variant can further degrade the top-1 accuracy from $1 8 . 4 5 \%$ (vanilla BIA) to $1 3 . 4 7 \%$ on average.
+
+4.2 COMBINATION OF DOMAIN-AGNOSTIC ATTENTION AND RANDOM NORMALIZATION
+
+In this section, we report the results for BIA equipped with both $\mathcal { R N }$ and $\mathcal { D A }$ . The following is the update rule:
+
+$$
+\theta ^ { * } = \underset { \theta } { \arg \operatorname* { m i n } } \ : \mathcal { L } _ { c o s } ( \mathcal { A } ^ { L } \odot f _ { s } ^ { L } ( \mathcal { R N } ( \boldsymbol { x } _ { s } ^ { \prime } ) ) , \boldsymbol { \mathcal { A } } ^ { L } \odot f _ { s } ^ { L } ( \mathcal { R N } ( \boldsymbol { x } _ { s } ) ) ) .
+$$
+
+As illustrated in Figure 4, $\mathcal { R N }$ module and $\mathcal { D A }$ module are not always mutually reinforcing. For example, when training against Res-152 and transferring adversarial examples to fine-grained or source domains, combining $\mathcal { R N }$ module and $\mathcal { D A }$ module can further decrease the average top-1 accuracy to $3 5 . 7 5 \%$ and $1 3 . 1 1 \%$ , respectively. However, if the black-box domain is coarse-grain,
+
+only applying $\mathcal { R N }$ module is better than applying both $\mathcal { R N }$ and $\mathcal { D A }$ modules. We speculate that it may be because the $\mathcal { R N }$ module affects the low-level features extract by the substitute model, and thus be incompatible with the $\mathcal { D A }$ module sometimes.
+
+Since Figure 4 shows that using $\mathcal { D A }$ and $\mathcal { R N }$ in tandem is less effective when training against Dense-169 while they reinforce each other in VGG-16 in most cases, we visualize the cross-channel average pooling of intermediate features for VGG-16 and Dense-169 to better explain this phenomenon. As illustrated in Figure 5, it can be observed that the $\mathcal { R N }$ module reinforces the discriminative features in VGG-16. However, it in
+
+![](images/4ecd10a3691d3714ff189539f01805d221cf14ddcec75d479aeab721ab4e2388.jpg)  
+Figure 4: The average top-1 accuracy of $\mathcal { D A }$ , $\mathcal { R N }$ and $\mathcal { D } \bar { \mathcal { A } } + \mathcal { R } \mathcal { N }$ variants after attacking on coarse-grained, fine-grained and source domains.
+
+hibits the response of objects’ essential features extracted by Dense-169. Consequently, $\mathcal { D A }$ module may cause the resulting generator to reduce the ability to attack essential features, thereby making it challenging to use these two techniques in tandem.
+
+![](images/ba820367a302ab95b1868a9130cf44d4e19cb1331f48670968e85446d3bf274e.jpg)  
+Figure 5: Visualization (cross-channel average pooling) of intermediate features for VGG-16 and Dense-169. It can be observed that the $\mathcal { R N }$ module inhibits the response of objects’ essential feature extracted by Dense-169, while VGG-16 enhances the response.
+
+# 5 CONCLUSION
+
+In this paper, we present a practical black-box threat model for the cross-domain attack. Specifically, we train a generator network in the large-scale ImageNet domain to disrupt low-level features better, thus generating transferable adversarial examples for the black-box domain. Based on this framework, we further propose two variants to narrow the gap between the source and target domains from the data and model perspectives, respectively. Extensive experiments demonstrate the effectiveness of our proposed methods. This also reminds the model owner that “Your deployed model is not safe even you do not leak any information to the public”. We hope our proposed approaches can serve as a benchmark for evaluating the stability of various deployed models.
+
+# 6 ACKNOWLEDGE
+
+This work was supported by the National Natural Science Foundation of China (Grant No.   
+62020106008, No. 61772116 and No. 61872064) and Alibaba Group.
+
+# REFERENCES
+
+Shumeet Baluja and Ian Fischer. Adversarial transformation networks: Learning to generate adversarial examples. CoRR, abs/1703.09387, 2017.
+
+Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. In ICLR, 2018.
+
+Nicholas Carlini and David A. Wagner. Towards evaluating the robustness of neural networks. In Symposium on Security and Privacy, 2017.
+
+Rich Caruana, Alexandru Niculescu-Mizil, Geoff Crew, and Alex Ksikes. Ensemble selection from libraries of models. In ICML, 2004.
+
+Jianbo Chen, Michael I. Jordan, and Martin J. Wainwright. Hopskipjumpattack: A query-efficient decision-based attack. In SP, 2020.
+
+Yue Chen, Yalong Bai, Wei Zhang, and Tao Mei. Destruction and construction learning for finegrained image recognition. In CVPR, 2019.
+
+Adam Coates, Andrew Y. $\mathrm { N g }$ , and Honglak Lee. An analysis of single-layer networks in unsupervised feature learning. In Geoffrey J. Gordon, David B. Dunson, and Miroslav Dud´ık (eds.), AISTATS, 2011.
+
+Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In CVPR, 2018.
+
+Ranjie Duan, Xiaofeng Mao, A. Kai Qin, Yuefeng Chen, Shaokai Ye, Yuan He, and Yun Yang. Adversarial laser beam: Effective physical-world attack to dnns in a blink. In CVPR, 2021.
+
+Lianli Gao, Qilong Zhang, Jingkuan Song, Xianglong Liu, and Hengtao Shen. Patch-wise attack for fooling deep neural network. In ECCV, 2020a.
+
+Lianli Gao, Qilong Zhang, Jingkuan Song, and Heng Tao Shen. Patch-wise $^ { + + }$ perturbation for adversarial targeted attacks. CoRR, abs/2012.15503, 2020b.
+
+Lianli Gao, Yaya Cheng, Qilong Zhang, Xing Xu, and Jingkuan Song. Feature space targeted attacks by statistic alignment. In IJCAI, 2021.
+
+Ian J. Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. In Yoshua Bengio and Yann LeCun (eds.), ICLR, 2015.
+
+Lars Kai Hansen and Peter Salamon. Neural network ensembles. IEEE Trans. Pattern Anal. Mach. Intell., 1990.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In CVPR, 2018.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In CVPR, 2017.
+
+Nathan Inkawhich, Wei Wen, Hai (Helen) Li, and Yiran Chen. Feature space perturbations yield more transferable adversarial examples. In CVPR, 2019.
+
+Nathan Inkawhich, Kevin J. Liang, Binghui Wang, Matthew Inkawhich, Lawrence Carin, and Yiran Chen. Perturbing across the feature hierarchy to improve standard and strict blackbox attack transferability. In Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin (eds.), NeurIPS, 2020.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.
+
+Jonathan Krause, Jia Deng, Michael Stark, and Li Fei-Fei. Collecting a large-scale dataset of finegrained cars. 2013.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NeurPIS, 2012.
+
+Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial examples in the physical world. In ICLR, 2017a.
+
+Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial machine learning at scale. In ICLR, 2017b.
+
+Xiaodan Li, Jinfeng Li, Yuefeng Chen, Shaokai Ye, Yuan He, Shuhui Wang, Hang Su, and Hui Xue. QAIR: practical query-efficient black-box attacks for image retrieval. In CVPR, 2021.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In ICLR, 2017.
+
+Ye Liu, Yaya Cheng, Lianli Gao, Xianglong Liu, Qilong Zhang, and Jingkuan Song. Practical evaluation of adversarial robustness via adaptive auto attack. In CVPR, 2022.
+
+Yantao Lu, Yunhan Jia, Jianyu Wang, Bai Li, Weiheng Chai, Lawrence Carin, and Senem Velipasalar. Enhancing cross-task black-box transferability of adversarial examples with dispersion reduction. In CVPR, 2020.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.
+
+Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew B. Blaschko, and Andrea Vedaldi. Fine-grained visual classification of aircraft. volume abs/1306.5151, 2013.
+
+Xiaofeng Mao, Yuefeng Chen, Shuhui Wang, Hang Su, Yuan He, and Hui Xue. Composite adversarial attacks. In AAAI, 2021.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: A simple and accurate method to fool deep neural networks. In CVPR, 2016.
+
+Konda Reddy Mopuri, Utkarsh Ojha, Utsav Garg, and R. Venkatesh Babu. NAG: network for adversary generation. In CVPR, 2018.
+
+Muzammal Naseer, Salman H. Khan, Muhammad Haris Khan, Fahad Shahbaz Khan, and Fatih Porikli. Cross-domain transferability of adversarial perturbations. In NeurPIS, 2019.
+
+Muzammal Naseer, Salman H. Khan, Munawar Hayat, Fahad Shahbaz Khan, and Fatih Porikli. A self-supervised approach for adversarial robustness. In CVPR, 2020.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. 2011.
+
+Nicolas Papernot, Patrick D. McDaniel, and Ian J. Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. CoRR, abs/1605.07277, 2016.
+
+Omid Poursaeed, Isay Katsman, Bicheng Gao, and Serge J. Belongie. Generative adversarial perturbations. In CVPR, 2018.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael S. Bernstein, Alexander C. Berg, and Fei-Fei Li. Imagenet large scale visual recognition challenge. IJCV, 2015.
+
+Mahmood Sharif, Sruti Bhagavatula, Lujo Bauer, and Michael K. Reiter. Accessorize to a crime: Real and stealthy attacks on state-of-the-art face recognition. In SIGSAC, 2016.
+
+Yucheng Shi, Siyu Wang, and Yahong Han. Curls & whey: Boosting black-box adversarial attacks. In CVPR, 2019.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In Yoshua Bengio and Yann LeCun (eds.), ICLR, 2015.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In Yoshua Bengio and Yann LeCun (eds.), ICLR, 2014.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In CVPR, 2016.
+
+Hugo Touvron, Alexandre Sablayrolles, Matthijs Douze, Matthieu Cord, and Herve J ´ egou. Grafit: ´ Learning fine-grained image representations with coarse labels. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 874–884, 2021.
+
+C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds-200-2011 Dataset. Technical report, California Institute of Technology, 2011.
+
+Xiaosen Wang, Xuanran He, Jingdong Wang, and Kun He. Admix: Enhancing the transferability of adversarial attacks. In ICCV, 2021.
+
+Xiaosong Wang, Yifan Peng, Le Lu, Zhiyong Lu, Mohammadhadi Bagheri, and Ronald M. Summers. Chestx-ray8: Hospital-scale chest x-ray database and benchmarks on weakly-supervised classification and localization of common thorax diseases. In CVPR, 2017.
+
+Dongxian Wu, Yisen Wang, Shu-Tao Xia, James Bailey, and Xingjun Ma. Skip connections matter: On the transferability of adversarial examples generated with resnets. In ICLR, 2020a.
+
+Weibin Wu, Yuxin Su, Xixian Chen, Shenglin Zhao, Irwin King, Michael R. Lyu, and Yu-Wing Tai. Boosting the transferability of adversarial samples via attention. In CVPR, 2020b.
+
+Cihang Xie, Zhishuai Zhang, Yuyin Zhou, Song Bai, Jianyu Wang, Zhou Ren, and Alan L. Yuille. Improving transferability of adversarial examples with input diversity. In CVPR, 2019.
+
+Kaidi Xu, Gaoyuan Zhang, Sijia Liu, Quanfu Fan, Mengshu Sun, Hongge Chen, Pin-Yu Chen, Yanzhi Wang, and Xue Lin. Adversarial t-shirt! evading person detectors in a physical world. In Andrea Vedaldi, Horst Bischof, Thomas Brox, and Jan-Michael Frahm (eds.), ECCV, 2020.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Zoubin Ghahramani, Max Welling, Corinna Cortes, Neil D. Lawrence, and Kilian Q. Weinberger (eds.), NeurIPS, 2014.
+
+Qilong Zhang, Chaoning Zhang, Chaoqun Li, Jingkuan Song, Lianli Gao, and Heng Tao Shen. Practical no-box adversarial attacks with training-free hybrid image transformation. CoRR, abs/2203.04607, 2022.
+
+Zhengyu Zhao, Zhuoran Liu, and Martha A. Larson. On success and simplicity: A second look at transferable targeted attacks. CoRR, abs/2012.11207, 2020.
+
+Wen Zhou, Xin Hou, Yongjun Chen, Mengyun Tang, Xiangqi Huang, Xiang Gan, and Yong Yang. Transferable adversarial perturbations. In Vittorio Ferrari, Martial Hebert, Cristian Sminchisescu, and Yair Weiss (eds.), ECCV, 2018.
+
+# A APPENDIX
+
+![](images/a3eb2cf3d05fabc4b32c9e9f34ad5e4e9486195d6355aacf96d920c8c62d5115.jpg)  
+Figure 6: Benign images sampled from each domain. From the top to the bottom rows are the first category, the middle category and the last category of their label space, respectively.
+
+![](images/742ca68f8adfdb07b0b2688fcc47f11ed2f4f5fbf9d0acac484a073811109501.jpg)  
+Figure 7: The structure of the generator.
+
+![](images/319485c961167e8f852f7873feb57a1fb4bded4e02eaef9e0b9ec9d1bf79d6df.jpg)  
+Figure 8: Adversarial examples crafted by CDA and our vanilla BIA $\epsilon = 1 0$ ). Both generator networks are trained against ImageNet pre-trained VGG-16 (Simonyan & Zisserman, 2015). Red highlighted labels represent misclassification.
+
+# A.1 SELECT LAYER FOR ATTACKING
+
+In this section, we analyze the impact of different intermediate layers of the substitute model on the transferability of resulting adversarial examples. The results are illustrated in Figure 10.
+
+In general, training against the shallow and middle layers yields more cross-domain transferable but less cross-model transferable adversarial examples than against the deep layer. For example, if the substitute model is Res-152, disrupting shallow layer Conv2 3 is more effective for transferring towards coarse-grained domain, and perturbing middle layer Conv3 8 is more effective in reducing the average top-1 accuracy of fine-grained models. In contrast, attacking deep layers like Conv5 3 can yield more transferable adversarial examples in the source domain. This demonstrates that lowlevel features are more similar across domains and high-level features are more domain-specific.
+
+# A.2 SELECT GAUSSIAN DISTRIBUTION FOR RANDOM NORMALIZATION
+
+For $\mathcal { D A }$ module, it is parameter-free. Therefore, we only conduct the experiment to select an optimal distribution for $\mathcal { R N }$ module, i.e., the $\mu ^ { \prime }$ and $\sigma ^ { \prime }$ in Equation 4. Here we tune the mean of $\mu ^ { \prime }$ and $\sigma ^ { \prime }$ from 0.25 to 0.75 with a granularity of 0.25. For the standard deviation of them, we fix it to 0.08 so that the sampled $\mu ^ { \prime }$ and $\sigma ^ { \prime }$ can basically take values ranging from 0.0 to 1.0 (according to the three-sigma rule).
+
+![](images/4955a0520f0dfb069af0d2360393bde7466120aebc110a8a60ecc7e0e354bbdd.jpg)  
+Figure 9: The average top-1 accuracy after attacking on coarse-grained (left), fine-grained (middle) and source (right) domains with different $\mu _ { m e a n } ^ { \prime }$ and $\sigma _ { m e a n } ^ { \prime }$ for $\mathcal { R N }$ .
+
+The results are shown in Figure 9, where we craft adversarial examples via VGG-16 and report the average top-1 accuracy in both source and black-box domains. From the results, we observe that a bigger $\sigma _ { m e a n } ^ { \prime }$ can effectively improve the transferability. For example, if we increase $\sigma _ { m e a n } ^ { \prime }$ from 0.25 to 0.75, the top-1 accuracy on fine-grained models can be further decreased by $3 . 1 6 \%$ on average. Although the influence of $\mu _ { m e a n } ^ { \prime }$ is relatively moderate when $\sigma _ { m e a n } ^ { \prime } = 0 . 7 5$ , setting $\mu _ { m e a n } ^ { \prime }$ to 0.5 is usually better. Therefore, we set $\mu ^ { \prime } \sim \mathcal { N } ( 0 . 5 0 , 0 . 0 8 )$ and $\sigma ^ { \prime } \sim \mathcal { N } ( 0 . 7 5 , 0 . 0 8 )$ in our paper.
+
+# A.3 DATA AUGMENTATION VS. RANDOM NORMALIZATION
+
+Data augmentation (Krizhevsky et al., 2012; Simonyan & Zisserman, 2015) is a widely used strategy for improving the generalization of the model. Nonetheless, these label-preserving transformations are less effective for training a generator to craft more transferable adversarial examples.
+
+In Figure 11, we report the results for our vanilla BIA, BIA with data augmentation $\left( \mathrm { B I A + A U G } \right)$ and BIA with $\mathcal { R N }$ $( \mathrm { B I A } { + } \mathcal { R N } )$ . As shown in Figure 11, $\mathrm { B I A + A U G }$ is less effective than our proposed $\mathbf { B } \mathbf { I A } { + } \mathcal { R N }$ and might even degrade the performance of our vanilla BIA. For example, when training against VGG-19, BIA gets an average top-1 accuracy of $5 8 . 7 1 \%$ on the fine-grained domain, yet $\mathrm { B I A + A U G }$ degrades it to $6 2 . 2 9 \%$ . In contrast, our proposed $\mathbf { B } \mathbf { I A } { + } \mathcal { R N }$ can significantly decrease the result to $4 7 . 7 8 \%$ . This is mainly because that the common data augmentation cannot effectively change the distribution of the training dataset, thus decreasing the generalization towards the black-box domain.
+
+# A.4 INSIGHT INTO THE GENERATOR
+
+Although many prior works (Poursaeed et al., 2018; Naseer et al., 2019) have leveraged the generator to craft adversarial examples, they hardly analyze the role of each block of the generator. This section will give an insight into the generator and understand how it processes an input. In Figure 12, we feed an image into the generator trained with the vanilla BIA (against Res-152) and visualize the output of each block. As we can observe, these blocks play different roles in crafting adversarial examples:
+
+![](images/cffcba5f5c5804d61a8eb199fb31cdc2b10ae019bcb69bc47c3424cebf3b65ac.jpg)  
+Figure 10: The average top-1 accuracy after attacking (the lower, the better) on coarse-grained, finegrained and source domains. Our generator $\mathcal { G } _ { \theta }$ is trained against different layers (from shallow to deep) of ImageNet pre-trained VGG-16, VGG-19, Res-152 and Dense-169, respectively.
+
+![](images/4ec3751736a8ca1997448b8ac8402ca0c000c1fec5f5e85e61492c892ceb1c60.jpg)  
+Figure 11: The average top-1 accuracy after attacking on coarse-grained, fine-grained and source domains. Here we compare the results of vanilla BIA, BIA with data augmentation (AUG) and BIA with $\mathcal { R N }$ . Our generator $\mathcal { G } _ { \theta }$ is trained against ImageNet pre-trained VGG-16, VGG-19, Res-152 and Dense-169, respectively.
+
+• Downsampling block: it mainly extracts discriminative features of the input image. As the size of the down-sampled images gets smaller, there is no significant noise overall.   
+• Residual block: Unlike the downsampling block, this block is responsible for adding noise and its behavior looks very similar to the iterative algorithm.   
+• Upsampling block: This block gradually reconstructs the adversarial example from abstract features.
+
+Since the residual block mainly works as suppressing or reversing the features extracted by the downsampling module, the downsampling module has an essential impact on generating transferable adversarial examples.
+
+To better understand the effectiveness of our proposed modules, here we investigate them from the perspective of the generator mechanism. Specifically, we apply crosschannel average pooling to the output of the downsampling block and calculate the difference map between vanilla BIA and our proposed variants. Without loss of generality, here we only show the definition of $D i f f ( \mathcal { R } \mathcal { N } v a r i a n t , ~ \mathbf { B } \mathbf { I } \mathbf { A } )$ , and $D i f f ( D A v a r i a n t$ , BIA) can be easily de
+
+![](images/c533ac52894362944c993885611d63588c7ef8cbe930655443a15ceffa0bd085.jpg)  
+Figure 13: A benign image (label is “Boeing 747”) from FGVC Aircraft (Maji et al., 2013) and its corresponding adversarial examples and difference map.
+
+duced. Specifically, we first apply cross-channel average pooling to the output of the downsampling
+
+![](images/eaa3a0a03e90e4247293ba6bf07592e5f6f00a59257c996993a39c4dff27f299.jpg)  
+Figure 12: We apply cross-channel average pooling to visualize each block of our generator $\mathcal { G } _ { \theta ^ { * } }$
+
+block:
+
+$$
+\begin{array} { r } { \mathcal { A } _ { R N } ^ { L } = \frac { \big | \sum _ { i = 0 } ^ { C } [ \mathcal { G } _ { R \mathcal { N } _ { \theta ^ { * } } } ^ { d } ( \pmb { x } ) ] _ { i } \big | } { C } , } \\ { \mathcal { A } _ { B I A } ^ { L } = \frac { \big | \sum _ { i = 0 } ^ { C } [ \mathcal { G } _ { B I A _ { \theta ^ { * } } } ^ { d } ( \pmb { x } ) ] _ { i } \big | } { C } , } \end{array}
+$$
+
+where $\mathcal { G } _ { \mathcal { R N } _ { \theta _ { \cdot } ^ { * } } } ^ { d }$ and $\mathcal { G } _ { B \mathcal { L } A _ { \theta ^ { * } } } ^ { d }$ denote the output of the downsampling block for $\mathcal { R N }$ variant and vanilla BIA, respectively. Then our difference map can be expressed by:
+
+$$
+D i f f ( { \mathcal { R } } { \mathcal { N } } v a r i a n t , B I A ) = { \left\{ \begin{array} { l l } { 1 , } & { A _ { R N } ^ { L } - A _ { B I A } ^ { L } > 0 , } \\ { 0 , } & { e l s e . } \end{array} \right. }
+$$
+
+From the result of Figure 13, we can observe that the generators derived from our proposed variants concentrate more on the body of the object (especially for $\mathcal { D A }$ variant) than that of vanilla BIA (which pays more attention to the background, i.e., the black region in the difference map). This demonstrates that our proposed $\mathcal { R N }$ and $\mathcal { D A }$ variants do narrow the domain gap, and thus be capable of yielding more transferable adversarial examples.
+
+# A.5 DISCUSSION ON CHANGING SOURCE DOMAIN
+
+Since all the experiments are only regarding from ImageNet domains to target domains, it is unclear how well the method will perform if the source dataset is different (especially when the source dataset is small). Therefore, in the following Table 5, we report the results for transferability from CUB-200-2011 to other domains. Generators are learned against CUB-200-2011 domain (the substitute model is DCL (backbone: Res-50) and training data is CUB-200-2011 testing data (5794 images)). For results of fine-grained domains, we average top-1 accuracy of backbone SENet-154 and SE-Res101. For the result of the ImageNet domain, we average top-1 accuracy of all models introduced in our manuscript. We can observe that our method consistently outperforms our main competitor CDA by a large margin. Besides, we also notice that transferring from CUB-200-2011 to CIFAR is very challenging (compared with our reported results in Table 2). Therefore, we highlight the necessity of using a large-scale dataset such as ImageNet to train the adversarial examples generator.
+
+Table 5: Transferability comparisons of CDA and our methods. Here we report the top-1 accuracy after attacking (the lower, the better). The generator $\mathcal { G } _ { \theta }$ is trained in CUB-200-2011 domain and adversarial examples are within the perturbation budget of $\ell _ { \infty } \leq 1 0$ .   
+
+<table><tr><td>Attacks</td><td>CUB-200-2011</td><td>CIFAR-10</td><td>CIFAR-100</td><td>STL-10</td><td>SVHN</td><td>Stanford Cars</td><td>FGVC Aircraft</td><td>ImageNet</td></tr><tr><td>CDA</td><td>64.34</td><td>83.61</td><td>54.83</td><td>70.49</td><td>91.81</td><td>74.37</td><td>71.17</td><td>50.99</td></tr><tr><td>BIA</td><td>40.40</td><td>82.62</td><td>54.57</td><td>71.43</td><td>91.67</td><td>68.25</td><td>57.90</td><td>44.15</td></tr><tr><td>BIA+DA</td><td>29.55</td><td>82.94</td><td>54.15</td><td>71.70</td><td>87.28</td><td>54.65</td><td>55.15</td><td>37.15</td></tr><tr><td>BIA+RN</td><td>42.88</td><td>83.84</td><td>53.63</td><td>69.79</td><td>87.95</td><td>57.01</td><td>50.85</td><td>39.43</td></tr></table>
+
+# A.6 DISCUSSION ON ENSEMBLE-MODEL ATTACKS
+
+As demonstrated in prior works (Liu et al., 2017; Dong et al., 2018; Mopuri et al., 2018), attacking against an ensemble of models can yield more transferable adversarial examples. However, it is not clear whether the ensemble-model attack is also effective in our cross-domain attack scenario. To investigate this, we conduct an experiment in Table 6, which shows the results for training against VGG-16 and an ensemble of VGG-16, Vgg-19, Res-152 and Dense-169, respectively.
+
+From the result, We can observe that ensemble-based training can also improve the transferability of adversarial examples towards black-box domains significantly.
+
+Table 6: Transferability comparisons of singe-model (i.e. VGG-16) attacks and ensemble-model (i.e. an ensemble of VGG-16, VGG-19, Res-152 and Dense-169) attacks. Here we report the top-1 accuracy after attacking (the lower, the better) and adversarial examples are within the perturbation budget of $\ell _ { \infty } \leq 1 0$ .   
+
+<table><tr><td></td><td>CIFAR-10</td><td>CIFAR-100</td><td>STL-10</td><td>SVHN</td><td>CUB-200-2011 (SENet-154)</td><td>Stanford Cars (SENet-154)</td><td>FGVC Aircraft (SENet-154)</td></tr><tr><td>BIA</td><td>57.38</td><td>22.47</td><td>69.45</td><td>90.44</td><td>52.99</td><td>69.90</td><td>60.31</td></tr><tr><td>BIA (ensemble)</td><td>54.96</td><td>21.73</td><td>68.94</td><td>85.85</td><td>29.15</td><td>46.47</td><td>36.87</td></tr><tr><td>BIA+DA</td><td>55.16</td><td>21.71</td><td>70.00</td><td>91.76</td><td>40.27</td><td>59.48</td><td>47.91</td></tr><tr><td>BIA+DA (ensemble)</td><td>52.97</td><td>20.51</td><td>69.51</td><td>89.15</td><td>18.47</td><td>38.99</td><td>25.41</td></tr><tr><td>BIA+RN</td><td>52.81</td><td>20.82</td><td>67.55</td><td>88.03</td><td>46.15</td><td>62.64</td><td>52.54</td></tr><tr><td>BIA+RN (ensemble)</td><td>50.99</td><td>22.35</td><td>66.06</td><td>81.66</td><td>35.40</td><td>41.87</td><td>27.81</td></tr></table>
+
+# A.7 DISCUSSION ON STANDARD DEVIATION ACROSS MULTIPLE RANDOM RUNS
+
+To ensure the stability and credibility of the evaluations, experiments are repeated several times for our methods. In Table 7, we report the results for each random seed and standard deviation across these random runs.
+
+Table 7: We show the results of 5 random seeds for methods. Here we report the top-1 accuracy after attacking (the lower, the better). The generator $\mathcal { G } _ { \theta }$ is trained against VGG-16 and adversarial examples are within the perturbation budget of $\ell _ { \infty } \leq 1 0$ .   
+
+<table><tr><td></td><td></td><td>CIFAR-10</td><td>CIFAR-100</td><td>STL-10</td><td>SVHN</td><td>CUB-200-2011 (SENet-154)</td><td>Stanford Cars (SENet-154)</td><td>FGVC Aircraft (SENet-154)</td><td>ImageNet (Res-152)</td></tr><tr><td rowspan="7">BIA</td><td>Paper report (Table2&amp;3&amp;4)</td><td>57.38</td><td>22.47</td><td>69.45</td><td>90.44</td><td>52.99</td><td>69.90</td><td>60.31</td><td>42.98</td></tr><tr><td rowspan="5">Random runs</td><td>56.75</td><td>21.86</td><td>69.61</td><td>90.48</td><td>52.47</td><td>68.13</td><td>61.45</td><td>44.04</td></tr><tr><td>57.31</td><td>22.32</td><td>69.83</td><td>90.35</td><td>52.04</td><td>69.48</td><td>57.37</td><td>41.67</td></tr><tr><td>57.13</td><td>22.82</td><td>70.06</td><td>90.01</td><td>53.27</td><td>69.74</td><td>58.54</td><td>41.02</td></tr><tr><td>57.03</td><td>22.38</td><td>70.05</td><td>90.43</td><td>53.04</td><td>71.91</td><td>62.02</td><td>43.09</td></tr><tr><td>57.36</td><td>22.50</td><td>69.55</td><td>89.78</td><td>51.48</td><td>68.15</td><td>58.36</td><td>42.00</td></tr><tr><td>Paper report</td><td>57.16 ± 0.24</td><td>22.39 ± 0.31</td><td>69.76±0.26</td><td>90.25±0.29</td><td>52.55 ± 0.69</td><td>69.55 ± 1.39</td><td>59.68 ± 1.86</td><td>42.47 ± 1.10</td></tr><tr><td rowspan="7">BIA+RN</td><td rowspan="5">(Table2&amp;3&amp;4)</td><td>52.81</td><td>20.82</td><td>67.55</td><td>88.03</td><td>46.15</td><td>62.64</td><td>52.54</td><td>31.80</td></tr><tr><td>52.56</td><td>21.12</td><td>66.75</td><td>88.63</td><td>44.84</td><td>63.18</td><td>51.55</td><td>30.71</td></tr><tr><td>52.63</td><td>21.43</td><td>67.24</td><td>87.93</td><td>48.38</td><td>63.4</td><td>55.09</td><td>33.76</td></tr><tr><td>52.29</td><td>21.42</td><td>67.3</td><td>88.64</td><td>45.41</td><td>63.2</td><td>52.99</td><td>31.8</td></tr><tr><td>52.60</td><td>21.68 21.66</td><td>67.21</td><td>87.69</td><td>48.88</td><td>63.98</td><td>52.69</td><td>29.56</td></tr><tr><td>53.41 52.70±0.42</td><td></td><td>67.00</td><td>88.40</td><td>49.01</td><td>64.16</td><td>55.96</td><td>30.96</td></tr><tr><td rowspan="7">BIA+DA</td><td>Paper report (Table2&amp;3&amp;4)</td><td></td><td>21.46 ± 0.23</td><td>67.10± 0.23 70.00</td><td>88.26 ± 0.43 91.76</td><td>47.30 ± 2.01 40.27</td><td>63.58 ± 0.46 59.48</td><td>53.66 ± 1.81</td><td>31.36 ± 1.56</td></tr><tr><td></td><td>55.16</td><td>21.71</td><td></td><td></td><td></td><td></td><td>47.91</td><td>36.43</td></tr><tr><td rowspan="5">Random runs</td><td>55.05</td><td>21.8</td><td>69.93</td><td>91.43</td><td>41.01</td><td>57.70</td><td>48.15</td><td>35.81</td></tr><tr><td>54.47</td><td>21.34</td><td>70.05</td><td>91.5</td><td>39.96</td><td>57.98</td><td>48.30</td><td>35.23</td></tr><tr><td>55.30</td><td>21.37</td><td>69.79</td><td>92.15</td><td>41.89</td><td>58.65</td><td>48.78</td><td>36.73</td></tr><tr><td>55.15</td><td>21.31</td><td>70.05</td><td>92.18</td><td>40.73</td><td>59.15</td><td>49.08</td><td>36.09</td></tr><tr><td>54.52</td><td>21.36</td><td>69.71</td><td>92.04</td><td>41.92</td><td>58.57</td><td>49.02</td><td>37.67</td></tr><tr><td>Paper report</td><td>Result 54.90 ± 0.38</td><td>21.44 ± 0.20</td><td>69.91 ± 0.15</td><td>91.86 ± 0.37</td><td>41.10 ± 0.83</td><td>58.41 ± 0.57</td><td>48.67 ± 0.42</td><td>36.31 ± 0.93</td></tr><tr><td rowspan="7">BIA+DA+RN</td><td>(Table 2&amp;3&amp;4)</td><td>50.29</td><td>20.03</td><td>67.51</td><td>90.4</td><td>40.46</td><td>57.26</td><td>37.01</td><td>24.91</td></tr><tr><td rowspan="5">Random runs</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>51.35</td><td>20.18 20.17</td><td>67.53</td><td>91.34</td><td>43.56 43.03</td><td>58.29 58.4</td><td>36.11 38.07</td><td>22.25 23.83</td></tr><tr><td>50.49 50.64</td><td>20.27</td><td>67.5 67.64</td><td>90.95 90.56</td><td>41.18</td><td>56.46</td><td>37.05</td><td>26.07</td></tr><tr><td>50.72</td><td>20.48</td><td>67.10</td><td>90.65</td><td>39.11</td><td>55.69</td><td>36.00</td><td>24.31</td></tr><tr><td>50.49</td><td>20.09</td><td>67.15</td><td>90.77</td><td>38.78</td><td>55.81</td><td>37.38</td><td>25.27</td></tr><tr><td>Result</td><td></td><td>50.74±0.36 20.24±0.15 67.38±0.24 90.85± 0.31</td><td></td><td></td><td>41.13 ± 2.19</td><td>56.93 ± 1.33</td><td>36.92 ± 0.87</td><td>24.35± 1.46</td></tr></table>
+
+A.8 EFFECTS OF $\mathcal { R N }$ AND $\mathcal { D A }$ ON COARSE-GRAINED AND FINE-GRAINED TASKS
+
+From Table 2 and Table 3, we observe that $\mathcal { R N }$ module is more effective than $\mathcal { D A }$ module for coarse-grained models, but not as well as $\mathcal { D A }$ module for fine-grained models. There may be two reasons:
+
+On the one hand, the default normalization of coarse-grained classification models is different from ImageNet and fine-grained classification models. Specifically, coarse-grained classification models use mean $= [ 0 . 5 , 0 . 5 , 0 . 5 ]$ and $\mathrm { s t d } = [ 0 . 5 , 0 . 5 , 0 . 5 ]$ , but ImageNet and and fine-grained classification models use mean $= [ 0 . 4 8 5 , 0 . 4 5 6 , 0 . 4 0 6 ]$ and $\mathrm { s t d } = [ 0 . 2 2 9 , 0 . 2 2 4 , 0 . 2 2 5 ]$ ; Therefore, using $\mathcal { R N }$ module can narrow normalization gap between ImageNet and coarse-grained domains.
+
+On the other hand, the resolution of coarse-grained domains such as CIFAR-10 and CIFAR-100 is much lower than the ImageNet domain and fine-grained domains. Therefore, the intermediate features of images from coarse-grained domains are more coarse than those from ImageNet and fine-grained domains, which may enlarge the gap between ImageNet and coarse-grained domains.

parse/dev/Qy1D9JyMBg0/Qy1D9JyMBg0_content_list.json

@@ -0,0 +1,1506 @@
+[
+    {
+        "type": "text",
+        "text": "Multimodal Contrastive Learning with LIMoE: the Language-Image Mixture of Experts ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            122,
+            789,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Basil Mustafa∗, Carlos Riquelme\\*, Joan Puigcerver\\*, Rodolphe Jenatton, Neil Houlsby Google Brain {basilm, rikel, jpuigcerver, rjenatton, neilhoulsby}@google.com ",
+        "bbox": [
+            199,
+            224,
+            797,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            303,
+            535,
+            320
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Large sparsely-activated models have obtained excellent performance in multiple domains. However, such models are typically trained on a single modality at a time. We present the Language-Image MoE, LIMoE, a sparse mixture of experts model capable of multimodal learning. LIMoE accepts both images and text simultaneously, while being trained using a contrastive loss. MoEs are a natural fit for a multimodal backbone, since expert layers can learn an appropriate partitioning of modalities. However, new challenges arise; in particular, training stability and balanced expert utilization, for which we propose an entropy-based regularization scheme. Across multiple scales, we demonstrate remarkable performance improvement over dense models of equivalent computational cost. LIMoE-L/16 trained comparably to CLIP-L/14 achieves $7 8 . 6 \\%$ zero-shot ImageNet accuracy (vs. $7 6 . 2 \\%$ ), and when further scaled to H/14 (with additional data) it achieves $8 4 . 1 \\%$ , comparable to state-of-the-art methods which use larger custom per-modality backbones and pre-training schemes. We analyse the quantitative and qualitative behavior of LIMoE, and demonstrate phenomena such as differing treatment of the modalities and the organic emergence of modality-specific experts. ",
+        "bbox": [
+            233,
+            334,
+            766,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            310,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sparsely activated mixture of expert (MoE) models have recently been used with great effect to scale up both vision [1, 2] and text models [3, 4]. The primary motivation for using MoEs is to scale model parameters while keeping compute costs under control. These models however have other benefits; for example, the sparsity protects against catastrophic forgetting in continual learning [5] and can improve performance for multitask learning [6] by offering a convenient inductive bias. ",
+        "bbox": [
+            176,
+            611,
+            825,
+            680
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Given success in each individual domain, and the intuition that sparse models may better handle distinct tasks, we explore the application of MoEs to multimodal modelling. We take the first step in this direction, and study models that process both images and text. In particular, we train a single multimodal architecture that aligns image and text representations via contrastive learning [7]. ",
+        "bbox": [
+            176,
+            686,
+            823,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When using a setup proposed in prior unimodal models [8, 1], we find that feeding multiple modalities to a single architecture leads to new failure modes unique to MoEs. To overcome these, we present a set of entropy based regularisers which stabilise training and improve performance. We call the resulting model LIMoE (Language-Image MoE). ",
+        "bbox": [
+            174,
+            748,
+            825,
+            804
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We train a range of LIMoE models which significantly outperform compute-matched dense baselines. We scale this up to a large 5.6B parameter LIMoE-H/14, which applies 675M parameters per token. When evaluated zero-shot [7] on ImageNet-2012 [9] it achieves an accuracy of $8 4 . 1 \\%$ , competitive with two-tower models that make use of modality-specific pre-training and feature extractors, and apply $3 { - } 4 \\mathbf { x }$ more parameters per token. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            880
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In summary, our contributions are as follows. ",
+        "bbox": [
+            174,
+            92,
+            470,
+            106
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose LIMoE, the first large-scale multimodal mixture of experts models.   \n• We demonstrate in detail how prior approaches to regularising mixture of experts models fall short for multimodal learning, and propose a new entropy-based regularisation scheme to stabilise training.   \nWe show that LIMoE generalises across architecture scales, with relative improvements in zero-shot ImageNet accuracy ranging from $7 \\%$ to $13 \\%$ over equivalent dense models. Scaled further, LIMoE-H/14 achieves $8 4 . 1 \\%$ zeroshot ImageNet accuracy, comparable to SOTA contrastive models with per-modality backbones and pre-training.   \n• Lastly, we present ablations and analysis to understand the model’s behavior and our design decisions. ",
+        "bbox": [
+            181,
+            119,
+            570,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/8eeba2d62d78eb816871876d9a4ee56cfc52e295d2cdec1da69f33730a297a8e.jpg",
+        "image_caption": [
+            "Figure 1: LIMoE, a sparsely activated multimodal model, processes both images and texts, utilising conditional computation to allocate computations in a modality-agnostic fashion. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            589,
+            37,
+            830,
+            314
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Multimodal Mixture of Experts ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            353,
+            468,
+            371
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multimodal contrastive learning typically works with independent per-modality encodings [7, 10]. That is, separate models $f _ { m }$ are trained to provide a final representation for every input from the corresponding modality, $m$ . In the case of some image and text inputs, i and t, we have $\\mathbf { z _ { i } } = f _ { \\mathrm { i m a g e } } ( \\mathbf { i } )$ and ${ \\bf z } _ { \\bf t } = f _ { \\mathrm { t e x t } } ( { \\bf t } )$ . For contrastive learning with images and text, this approach results in a “two-tower” architecture, one for each modality. We study a one-tower setup instead, where a single model is shared for all modalities, as shown in Figure 1. The one-tower design offers increased generality and scalability, and the potential for cross-modal and cross-task knowledge transfer. We next describe the LIMoE architecture and training routine. ",
+        "bbox": [
+            173,
+            386,
+            570,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            398,
+            825,
+            497
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Multimodal contrastive learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            439,
+            530
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given $n$ pairs of images and text captions $\\{ ( \\mathbf { i } _ { j } , \\mathbf { t } _ { j } ) \\} _ { j = 1 } ^ { n }$ , the model learns representations $\\mathcal { Z } _ { n } = \\{ ( \\mathbf { z _ { i } } _ { j } , \\mathbf { z _ { t } } _ { j } ) \\} _ { j = 1 } ^ { n }$ such that those corresponding to paired inputs are closer in feature space than those of unpaired inputs. The contrastive training objective [7, 11], with learned temperature $T$ , is: ",
+        "bbox": [
+            176,
+            539,
+            825,
+            584
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0cb8c134d67481dd949d36ca01df33d630637575d17a0efa1cdb9ecf8fbd23f7.jpg",
+        "text": "$$\n\\mathcal { L } _ { j } ( \\mathcal { Z } _ { n } ) = - \\frac { 1 } { 2 } \\log \\frac { e ^ { \\langle \\mathbf { z _ { i _ { j } } } , \\mathbf { z _ { t _ { j } } } \\rangle / T } } { \\sum _ { k = 1 } ^ { n } e ^ { \\langle \\mathbf { z _ { i _ { j } } } , \\mathbf { z _ { t _ { k } } } \\rangle / T } } - \\frac { 1 } { 2 } \\log \\frac { e ^ { \\langle \\mathbf { z _ { i _ { j } } } , \\mathbf { z _ { t _ { j } } } \\rangle / T } } { \\sum _ { k = 1 } ^ { n } e ^ { \\langle \\mathbf { z _ { i _ { k } } } , \\mathbf { z _ { t _ { j } } } \\rangle / T } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            592,
+            717,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 The LIMoE Architecture ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            678,
+            379,
+            693
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We use a single Transformer-based architecture for both image and text modalities. The model uses a linear layer per modality to project the intrinsic data dimension to the desired width: for text, a standard one-hot sentencepiece encoding and learned vocabulary [12], and for images, ViT-style patch-based embeddings [13]. Then all tokens are processed by a shared transformer encoder, which is not explicitly conditioned on modality. The token representations from the final layer are averagepooled to produce a single representation vector $\\mathbf { z } _ { m }$ for each modality. To compute the training loss in (1), the paired image and text representations are then linearly projected using per-modality weight matrices $\\mathbf { W } _ { m }$ ’s and ${ \\mathcal { L } } _ { j }$ is applied to $\\{ ( \\mathbf { W } _ { \\mathrm { i m a g e } } \\mathbf { \\Lambda } \\mathbf { z _ { i _ { k } } } , \\mathbf { W } _ { \\mathrm { t e x t } } \\mathbf { \\Lambda } \\mathbf { z _ { t _ { k } } } ) \\} _ { k = 1 } ^ { \\bar { n } }$ . ",
+        "bbox": [
+            173,
+            704,
+            826,
+            816
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This one-tower setup can be implemented with a standard dense Transformer (and we train many such models as baselines). Next, we describe how we introduce MoEs to this setup for LIMoE. ",
+        "bbox": [
+            174,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Sparse MoE backbone: Sparse MoE layers are introduced following the architectural design of [1, 3]. The experts—parts of the model activated in an input-dependent fashion—are MLPs. LIMoE contains multiple MoE layers. In those layers, each token $\\mathbf { x } \\in \\mathbb { R } ^ { D }$ is processed sparsely by $K$ out of $E$ available experts. To choose which $K$ , a lightweight router predicts the gating weights per token: ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/0dba0eb0d7f5394cb7861652bd1f0a30fe2c7060fad594e8077fcfc13bfc8625.jpg",
+        "image_caption": [
+            "Figure 2: Token routing examples for Coco. Image examples of how patches are routed at the MoE layer placed in the 18-th encoder block –i.e. middle of the network– for the LIMoE-H/14 model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            95,
+            823,
+            290
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$g ( \\mathbf { x } ) = \\mathsf { s o f t m a x } ( \\mathbf { W } _ { g } \\mathbf { x } ) \\in \\mathbb { R } ^ { E }$ with learned $\\mathbf { W } _ { g } \\in \\mathbb { R } ^ { D \\times E }$ . The outputs of the $K$ activated experts are linearly combined according to the gating weights: $\\begin{array} { r } { \\mathtt { M o E } ( \\mathbf { x } ) = \\sum _ { e = 1 } ^ { K } g ( \\mathbf { x } ) _ { e } \\cdot \\mathtt { M L P } _ { e } ( \\mathbf { x } ) . } \\end{array}$ . ",
+        "bbox": [
+            173,
+            359,
+            823,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that, for computational efficiency and implementation constraints, experts have a fixed buffer capacity. The number of tokens each expert can process is fixed in advance, and typically assumes that tokens are roughly balanced across experts. If capacity is exceeded, some tokens are “dropped”; they are not processed by the expert, and the expert output is all zeros for those tokens. The rate at which tokens are successfully processed (that is, not dropped) is referred to as the “success rate”. It is an important indicator of healthy and balanced routing and often indicative of training stability. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We discovered that routing with tokens from multiple modalities introduces new failure modes; in the next sections we demonstrate this phenomenon, and describe our techniques to address it. ",
+        "bbox": [
+            173,
+            489,
+            823,
+            517
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 Challenges for multimodal MoEs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            539,
+            455,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As mentioned, experts have a fixed buffer capacity. Without intervention, Top- $K$ MoEs tend to “collapse”, thus using only one expert. This causes most tokens to be dropped and leads to poor performance [14]. Prior works therefore use auxiliary losses to encourage balanced routing [1, 3, 8]. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In multimodal settings, new challenges arise; one is modality misbalance. In realistic setups, there will likely be more of one data type than another. Accordingly, we do not assume or enforce balanced data across modalities, and our experiments have $3 - 1 7 \\times$ more image tokens than text tokens. ",
+        "bbox": [
+            176,
+            614,
+            823,
+            656
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Modality-specific experts tend to emerge naturally. In this imbalanced context, this leads to a scenario where all of the tokens from the minority modality get assigned to a single expert, which runs out of capacity. On a global level, routing still appears balanced: tokens from the majority modality are nicely distributed across experts, thereby satisfying modality-agnostic auxiliary losses. For example, in our standard B/16 setup, the router can optimize the importance loss [14] to within $0 . 5 \\%$ of its minimum value by perfectly balancing image tokens but dropping all text tokens. This however leads to unstable training and unperforming models. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            758
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 Auxiliary losses ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            333,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We refer to auxiliary losses used in V-MoE [1] as the classic auxiliary losses. We find that they do not yield stable and performant multimodal MoE models. Therefore, we introduce two new losses: the local entropy loss and the global entropy loss, which are applied on a per-modality basis. We combine these losses with the classic losses; see Appendix B for a summary of all auxiliary losses. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition. In each MoE layer, for each modality $m$ , the router computes a gating matrix ${ \\bf G } _ { m } \\in  { \\bf \\Psi }$ $\\mathbb { R } ^ { n _ { m } \\times E }$ . Each row of $\\mathbf { G } _ { m }$ represents the probability distribution over $E$ experts for one of the $n _ { m }$ tokens of that modality in the batch. For a token $\\mathbf { x }$ that corresponding row is $\\ L _ { j _ { m } } ( \\mathbf { e x p e r t s } | \\mathbf { x } ) \\in \\mathbb { R } ^ { E }$ ; ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "this later dictates which experts process $\\mathbf { x }$ . The local and global entropy losses are defined by: ",
+        "bbox": [
+            168,
+            90,
+            789,
+            107
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca8302d1e894cd6159de03f2d0169479f23338f2bfe1e5eb9af7b60389be835d.jpg",
+        "text": "$$\n\\Omega _ { \\mathrm { l o c a l } } ( \\mathbf { G } _ { m } ) : = \\frac { 1 } { n _ { m } } \\sum _ { i = 1 } ^ { n _ { m } } \\mathcal { H } ( p _ { m } ( \\boldsymbol { \\mathrm { e x p e r t s } } | \\mathbf { x } _ { i } ) ) \\mathrm { a n d } \\Omega _ { \\mathrm { g l o b a l } } ( \\mathbf { G } _ { m } ) : = - \\mathcal { H } ( \\tilde { p } _ { m } ( \\boldsymbol { \\mathrm { e x p e r t s } } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            209,
+            117,
+            781,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\tilde { p } _ { m } ( \\boldsymbol { \\mathbf { e x p e r t s } } ) = \\frac { 1 } { n _ { m } } \\sum _ { i = 1 } ^ { n _ { m } } p _ { m } ( \\boldsymbol { \\mathbf { e x p e r t s } } | \\boldsymbol { \\mathbf { x } } _ { i } ) } \\end{array}$ is the expert probability distribution averaged over the tokens and $\\begin{array} { r } { \\mathcal { H } ( p ) = - \\sum _ { e = 1 } ^ { E } p _ { e } \\log ( p _ { e } ) } \\end{array}$ denotes the entropy. Note that $\\widetilde { p } _ { m } ( \\mathrm { e x p e r t s } ) \\approx$ $p _ { m }$ (experts) since we approximate the true marginal from the tokens in the batch. We use the terminology local vs. global to emphasise the fact that $\\Omega _ { \\mathrm { l o c a l } }$ applies the entropy locally for each token while $\\Omega _ { \\mathrm { g l o b a l } }$ applies the entropy globally after having marginalized out the tokens. ",
+        "bbox": [
+            173,
+            171,
+            825,
+            248
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Effects of the losses. Figure 3 shows why these losses are necessary. With the default losses, modality-specific experts naturally emerge, but the router often changes its preference. This results in unstable training and poor success rate, particularly for the text modality. The local entropy loss encourages concentrated router weights $( p _ { \\mathrm { t e x t } } ( \\mathbf { e x p e r t s } | \\mathbf { x } _ { i } )$ ’s have low entropy), but at the expense of the diversity of the text experts: the same expert is used for all text tokens (the marginal $\\tilde { p } _ { \\mathrm { t e x t } } ( \\mathbf { e x p e r t s } )$ also has low entropy), leading to dropping. In this setup, many layers have poor text success rates. ",
+        "bbox": [
+            174,
+            253,
+            825,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To address this, $\\Omega _ { \\mathrm { g l o b a l } }$ encourages maximization of the marginal entropy, thus pushing $\\tilde { p } _ { \\mathrm { t e x t } } ( \\mathbf { e x p e r t s } )$ towards a more uniform expert distribution. The result is diverse expert usage, stable and confident routing, and high success rates. These are consequently the most performant models. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            386
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, it is desirable for text tokens to use multiple experts, but not all of them. In order to allow flexibility, we threshold the global entropy loss as $\\Omega _ { \\mathrm { g l o b a l } } ^ { \\tau } ( \\mathbf { G } _ { m } ) = \\operatorname* { m a x } \\{ 0 , \\tau + \\Omega ^ { \\mathrm { g l o b a l } } ( \\mathbf { G } _ { m } ) \\}$ , such that the model is encouraged to have a certain minimum entropy, but after exceeding that, the loss is not applied. This avoids distributional collapse but does not apply overly restrictive priors on the routing distribution, as there are many optimal solutions. This can be thought of as a “soft minimum” $S$ . With $\\tau = \\log ( S )$ , the model must use at least $S$ experts to minimize the loss (either a uniform distribution across $S$ experts -with entropy $\\log ( S ) .$ -, or a non-uniform distribution using more than $S$ ). Figure 3b shows the latter occurs; the empirical effect of these thresholds is analysed in Section 4.1. ",
+        "bbox": [
+            173,
+            391,
+            826,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b2a40b88d4645387584f6c2d2126829a0805542cea992fdb2dcd26d91f2b0b7d.jpg",
+        "image_caption": [
+            "(b) Analysing routing behaviour of the auxiliary losses. First column: Average success rate of image routing in layers 1/7/11. Second column: Same, for text. Third column: In some experts of layer 5, what fraction of all text tokens go to those experts ",
+            "Figure 3: What necessitates entropy losses? Classic refers to the standard formulation (importance $^ +$ load losses [1]). We add the local entropy loss to text tokens (middle row), followed by the global entropy loss (bottom row). Left: The “classic” setting is low-performing and unstable. Right: Analyzing the entropies shows us why: Without the local loss, the model is prone to unstable changes in expert preferences (C1), and routing success rates are low (A1, B1). The local loss fixes this but causes distributional collapse for one modality (C2), with all text tokens going to one expert (expert 11); this causes even poorer text success rates (B2). This is addressed by the global loss, which has stable expert allocations (C3) and consistently high success rates (A3, B3). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            133,
+            526,
+            861,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Connection with mutual information. The sum $\\Omega _ { \\mathrm { l o c a l } } ( { \\bf G } _ { m } ) + \\Omega _ { \\mathrm { g l o b a l } } ( { \\bf G } _ { m } )$ corresponds to the (negative) mutual information [15] between experts and tokens, conditioned on the modality $m$ , which we write $- \\mathbf { M } \\mathbf { I } _ { m } \\big ( \\mathbf { e x p e r t s ; x } \\big )$ . For each modality taken separately, we are effectively encouraging the knowledge of the token representation to reduce the uncertainty about the experts selection. We also tried other variants of the losses which exploit this connection, such as the mutual information between the experts and modalities, $- \\mathbf { M I } ( \\mathbf { e x p e r t s } ; m )$ , obtained by first marginalizing the tokens. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2.3 Priority routing ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            190,
+            336,
+            205
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With Top- $K$ routing, some token dropping is virtually inevitable. Batch Priority Routing (BPR) [1] actively decides which tokens to skip based on their routing weights. It assumes that tokens with a large routing weight are likely to be informative, and should be favored. BPR was mostly used at inference time in [1], allowing for smaller expert capacity buffers. In this setup, one must take care not to systematically favor one modality over the other, for instance, by determining which token to drop based on their rank in the batch, which are usually grouped according to the token modality. BPR provides an essential stabilisation effect during training (Figure 6); we show that it does not trivially rank one modality over another, and it cannot be replaced by other methods of re-ordering the batch. In the appendix we further show how routing priorities compare across text and images. ",
+        "bbox": [
+            174,
+            213,
+            825,
+            339
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            358,
+            312,
+            376
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We study LIMoE in the context of multimodal contrastive learning. We first perform a controlled comparison of LIMoE to an equivalent “standard” dense Transformer, across a range of model sizes. We then show that when scaled up LIMoE can reach a high level of performance. Finally, we ablate the various design decisions leading to LIMoE in Section 4. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training data. By default, all models are trained on paired image-text data used in [16], consisting of 3.6B images and alt-texts scraped from the web. For large LIMoE-H/14 experiment, we also co-train with JFT-4B [17]. We construct artificial text captions from JFT by comma-delimited concatenation of the class names [18]. Appendix A contains full details of our training setup. ",
+        "bbox": [
+            174,
+            452,
+            823,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Evaluation. Our main evaluation is “zero-shot”: the model uses its text representations of the classes to make predictions on a new task without extra training data [19, 7]. We focus on image classification accuracy on ImageNet [9] and cross-modal retrieval on MS-COCO [20], following the protocol in [16]. We also evaluate LIMoE’s image representations via a linear adaptation protocol [13], and report 10-shot accuracy on ImageNet accuracy accordingly. Where ranges are given, they report $9 5 \\%$ confidence intervals across three trials. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Controlled study across scales ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            419,
+            628
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We train a range of LIMoE models at batch size 16k for 781k steps. This matches the number of training examples used for CLIP [7]. Due to use of different training data and additional tricks, a direct comparison is difficult; we therefore train dense one-tower models as baselines. All models activate $k = 1$ experts per token, similar to Switch Transformer [8]. ",
+        "bbox": [
+            174,
+            640,
+            825,
+            695
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the performance of each model (dense and sparse) against forward-pass FLOPs (for step times and further discussion on compute costs, see Appendix D.2.). The cost-performance Pareto frontier for LIMoE dominates the dense models by a wide margin, indicating that LIMoE offers strong improvements across all scales from S/32 , up to L/16. The effect is particularly large on zero-shot and 10-shot ImageNet classification, with absolute performance improvements of $1 0 . 1 \\%$ and $12 . 2 \\%$ on average. For text-to-image retrieval on COCO, LIMoE offers a strong boost at small scales, while at larger scales the gains are more modest but still significant. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Scaling up LIMoE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            816,
+            333,
+            832
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We increase the architecture size, training duration, and data size to assess the performance of LIMoE in the large-scale regime. In particular, we train a 32-layer LIMoE-H/14 with 12 expert layers; these are non-uniformly distributed, with 32 experts per layer, and $K = 1$ activated per token. It was trained at a batch size of 21k, introducing $2 5 \\%$ JFT-4B images [17] into each batch (with class names as texts). We average checkpoints towards the end of training [21]; refer to Appendix A.3 for details. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0d34beaf46f0869823a29e8690c67130cab31729b0bf0a2f5794a23881b3ac4.jpg",
+        "image_caption": [
+            "Figure 4: LIMoE scales well to large models, with consistent performance improvements. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            92,
+            818,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The model contains 5.6B parameters in total, but only applies 675M parameters per token. All routers combined account for less than $0 . 5 \\mathbf { M }$ parameters. Table 1 shows its performance alongside current state-of-the-art contrastive models. LIMoE achieves $8 4 . 1 \\%$ zero-shot ImageNet classification accuracy with a comparably modest architecture size and training counts. LIMoE is fully trained from scratch, without any pre-trained components, and is the first competitive model with a shared backbone. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In light of its modality agnostic approach, this result is surprisingly strong. Large models handling dozens of distinct tasks are increasingly popular [22], but do not yet approach the state-of-the-art in these tasks. We believe the ability to build a generalist model with specialist components, which can decide how different modalities or tasks should interact, will be key to creating truly multimodal multitask models which excel at everything they do. LIMoE is a promising first step in that direction. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            448
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/8b1c5c57cf1302c8acb1442a3e7b387d2270dfc40e9e2c9f463c0b8ab95f4415.jpg",
+        "table_caption": [
+            "Table 1: Comparing state of the art zero-shot classification models. At a relatively modest scale, LIMoE-H/14 is comparable with the best two-tower models, and it is the first performant one-tower model at this scale. T- $\\mathbf { x }$ refers to a Transformer [23] with the equivalent parameters of ViT- $\\mathbf { x }$ [13]. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Key: Pretrained</td><td colspan=\"3\">Examplesseen duringpretraining</td><td>UsesFixRes[24]</td><td>3Other non-contrastivetrainingobjective</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td colspan=\"2\">Architecture</td><td>Batch</td><td>Examples seen</td><td>Parameters</td><td colspan=\"4\">ImageNet top-1 % Test</td></tr><tr><td></td><td>Image</td><td>Text</td><td>size</td><td></td><td>per token</td><td></td><td>V2</td><td>R</td><td></td></tr><tr><td>COCA [25]</td><td>ViT-g</td><td>T-g</td><td>65k</td><td>32.8B</td><td>1.1B</td><td>86.3</td><td>80.7</td><td>96.5</td><td>90.2</td></tr><tr><td>BASIC[18]</td><td>CoAtNet-7*</td><td>T-H*</td><td>65k</td><td>19.7BPT +32.8B</td><td>1.5B</td><td>85.7</td><td>80.6</td><td>95.7</td><td>85.6</td></tr><tr><td>LIT[16]</td><td>ViT-g*</td><td>T-g</td><td>32k</td><td>25.8BPT + 18.2B</td><td>1.1B</td><td>84.5</td><td>78.7</td><td>93.9</td><td>79.4</td></tr><tr><td>ALIGN [10]</td><td>EffNet-L2</td><td>T-L*</td><td>16k</td><td>19.8B</td><td>~410M</td><td>76.4</td><td>70.1</td><td>92.2</td><td>75.8</td></tr><tr><td>CLIP [7]</td><td>ViT-L/14†</td><td>T-B</td><td>32k</td><td>12.8B</td><td>~ 200M</td><td>76.2</td><td>70.1</td><td>88.9</td><td>77.2</td></tr><tr><td>LIMoE</td><td colspan=\"2\">H/14</td><td>21k</td><td>23.3B</td><td>675M</td><td>84.1</td><td>77.7</td><td>94.9</td><td>78.7</td></tr></table>",
+        "bbox": [
+            173,
+            512,
+            826,
+            659
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            684,
+            285,
+            702
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use a smaller setup to study various aspects of LIMoE. We train B/16 models at batch size 8096 for 100,000 steps (see Appendix A.2 for further details). Table 2 shows the average over three trials of this setting alongside dense one-tower and two-tower baselines. LIMoE greatly outperforms both dense models on ImageNet 0- and 10-shot, while confidence intervals overlap for retrieval with two towers. The two-tower model is twice as large and expensive, and still falls behind the sparse one. ",
+        "bbox": [
+            174,
+            715,
+            825,
+            785
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Routing and auxiliary losses ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            801,
+            408,
+            815
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Choice of auxiliary losses. With the introduction of the entropy based losses in addition to classic ones, there are 7 possible auxiliary losses. We aimed to find the simplest combination of these which obtains good performance. To study this, we performed a large sweep of auxiliary losses: for $N \\in [ 2 , \\ldots , 5 ]$ , we considered all $\\binom { 7 } { N }$ possible loss combinations. Table 3 shows, for each loss, the highest performing model with and without that loss. Some conclusions stand out: Both entropy losses are important for text, but for images, the global loss is not impactful and the local loss is harmful. The final combination of losses was chosen based on validation accuracy alongside qualitative observations around training stability and routing success rate. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/eebf53b815e680d748266e92f15c0d4f6866cd7df68f202903d49073cd9dbdde.jpg",
+        "table_caption": [
+            "Table 2: Baselines for ablations: B/16 with batch size 8096 trained for for 100,000 steps. 0shot and 10shot columns show accuracy $( \\% )$ , t2i and i2t show recall $@ 1$ $( \\% )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>i1k Oshot</td><td>i1k 10shot</td><td>coco t2i</td><td></td><td>coco i2t</td></tr><tr><td>dense one-tower</td><td>49.8 50.4 49.2</td><td>43.8 44.3 43.3</td><td>23.7 24</td><td>23.4</td><td>36.7 38.9 34.6</td></tr><tr><td>dense two-tower</td><td>54.7 55.2 54.1</td><td>47.1 47.6 46.7</td><td>26.6 27.1 26.2</td><td></td><td>41.3 42.0 40.6</td></tr><tr><td>LIMoE</td><td>B71 56.9</td><td>58 50.5</td><td>25.6</td><td>28</td><td>39.7 42.2 37.1</td></tr></table>",
+        "bbox": [
+            274,
+            137,
+            722,
+            209
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/f28ac8f31de0ecb3b355084931c2416f4ea183e2d2c456d350e5c751744dcc82.jpg",
+        "table_caption": [
+            "Table 3: Across 121 combinations, each row shows the best accuracy $( \\% )$ of all combinations that included the auxiliary loss $( \\checkmark )$ vs. those that did not $( { \\pmb x } )$ . Bold auxiliary losses indicate they are in LIMoE. Validation accuracy is the average contrastive accuracy in a minibatch of size 1024. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Validation</td><td colspan=\"2\">Oshot</td><td colspan=\"2\">10shot</td></tr><tr><td>Auxiliary loss</td><td>X</td><td>√</td><td>X</td><td>√</td><td>X</td><td>√</td></tr><tr><td>Importance</td><td>70.5</td><td>70.6</td><td>55.4</td><td>56.2</td><td>51.1</td><td>51.3</td></tr><tr><td>Load</td><td>70.3</td><td>70.6</td><td>56.2</td><td>55.7</td><td>51.3</td><td>51.1</td></tr><tr><td>Z-Loss</td><td>70.3</td><td>70.6</td><td>55.8</td><td>56.2</td><td>50.5</td><td>51.3</td></tr><tr><td>Global Ent Image</td><td>70.6</td><td>70.5</td><td>56.0</td><td>56.2</td><td>50.8</td><td>51.3</td></tr><tr><td>Global Ent Text</td><td>69.1</td><td>70.6</td><td>54.3</td><td>56.2</td><td>51.1</td><td>51.3</td></tr><tr><td>Local Ent Image</td><td>70.6</td><td>68.7</td><td>56.2</td><td>53.5</td><td>51.3</td><td>47.5</td></tr><tr><td>Local Ent Text</td><td>67.2</td><td>70.6</td><td>53.3</td><td>56.2</td><td>47.5</td><td>51.3</td></tr></table>",
+        "bbox": [
+            269,
+            282,
+            725,
+            424
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            449,
+            823,
+            477
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Threshold for global entropy losses. In Section 2.2.2, we introduced a threshold $\\tau$ to encourage balanced expert distributions without forcing all modalities to use all experts. To understand the importance of this threshold, we sweep over it for both the image and text global entropy losses. Appendix B.2 contains a full analysis; the most important conclusions are: ",
+        "bbox": [
+            173,
+            483,
+            825,
+            540
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• $\\tau _ { \\mathrm { i m a g e } }$ did not affect the number of experts used for images, as global entropy was always high. Aside from these threshold experiments with very high $\\tau _ { \\mathrm { i m a g e } }$ , this loss is usually inactive. It was used in our main experiments, but can likely be removed in future work. • The threshold $\\tau _ { \\mathrm { t e x t } }$ behaved exactly as a soft minimum for text experts: Sweeping $\\tau _ { \\mathrm { t e x t } }$ , we typically observed approximately $S = e ^ { \\tau _ { \\mathrm { t e x t } } }$ text experts. • Performance is robust to different values of $\\tau _ { \\mathrm { t e x t } }$ , provided it is not too low. A low $\\tau _ { \\mathrm { t e x t } }$ can be useful to limit the number of text experts, for later pruning, see Appendix E.4. ",
+        "bbox": [
+            173,
+            550,
+            826,
+            659
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Mutual-information auxiliary loss. In Section 2.2.2, we discussed an alternative loss, namely −MI(experts; m), based on the mutual information between experts and modalities. While it has the advantage of merging the local and global entropy losses for both the text and image modalities into a single term, without threshold parameters, it leads to slightly worse results: in a comparable setup, it had $1 . 5 \\%$ and $0 . 1 \\%$ worse zero-shot and 10-shot performance compared to Table 2. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The effect of modality balancing. Our models use a text sequence length of 16, but image sequence lengths from 49 to 400 (for these ablations, 196). ",
+        "bbox": [
+            173,
+            752,
+            516,
+            794
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our ablations reveal that the entropy losses are most important when applied to the text tokens. This leads to a hypothesis that these are only necessary or useful in the imbalanced case. To test this, we vary the modality balance of LIMoE-B/16 by varying the patch size; this enables us to control the number of image tokens, and hence image:text balance, without changing the information content in the data. Figure 5 shows the results. First, we observe that, with entropy routing, a longer image sequence length is always better. This shows that entropy routing can effectively handle highly imbalanced setups, and mirrors the observation that for classical Vision Transformers: a longer sequence is better. Importantly, entropy routing is always far superior to the classical setup with growing gaps, even when the modalities are balanced 1:1 ( $L _ { \\mathrm { i m g } } = 1 6 $ ). This experiment also confirms the robustness of entropy routing to different setups. ",
+        "bbox": [
+            174,
+            800,
+            517,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c8221e4e8f21d5d938c2021afc77bffbe44052e6a5771f002dfb281e1fdf415a.jpg",
+        "image_caption": [
+            "Figure 5: Entropy losses are not just addressing a modality imbalance. With different image:text balancing, including completely balanced, the entropy losses substantially improves over the classic setting. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            532,
+            742,
+            818,
+            893
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Batch priority routing as a training stabilizer. Figure 6 shows the effect of BPR during training. BPR not only ameliorates against token dropping, but also improves training stability. Models with no dispatch order intervention (first-in-first-out) perform extremely poorly, whether we route images first or text first. These routers have low success rate. Randomly shuffling tokens (i.e. deciding which tokens to drop at random when an expert becomes full) partially ameliorates this, but its performance is still much worse than that of models trained with BPR. We further analyse BPR in Appendix F.5 and show that it does not simply rank one modality above another. ",
+        "bbox": [
+            173,
+            181,
+            826,
+            279
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f8731692c249ccf80dd2a2093e9d2bd9f03365dd66a90ed68048ba6eed1c733b.jpg",
+        "image_caption": [
+            "Figure 6: BPR stabilizies training and enables performant models; the first figure shows different performance metrics. The last two show success rates for the MoE router in Layer 9. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            258,
+            297,
+            740,
+            434
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Other ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            507,
+            321,
+            522
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We summarize our other ablations here due to space constraints; details can be found in Appendix E. ",
+        "bbox": [
+            174,
+            535,
+            823,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Router structure (Appendix E.3). Our router is modality agnostic; we experiment with per-modality routers, and separate pools of per-modality experts. We find they all perform comparably to our generic, modality agnostic setup, but that separate pools of experts by design is more stable and does not require auxiliary losses for regularisation—while harder to scale to many modalities and tasks. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            611
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Increasing selected experts per token $K$ ( Appendix E.1). We propose modifications to BPR and the local auxiliary loss to generalise to $K > 1$ ; by doing so we can steadily increase performance by increasing $K$ , e.g. from $5 5 . 5 \\%$ zero-shot accuracy with $K = 1$ to $6 1 . 0 \\%$ with $K = 5$ . ",
+        "bbox": [
+            176,
+            617,
+            823,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Total number experts (Appendix E.2). We show that increasing the pool of available experts at fixed $K$ improves performance (unlike what was observed for vision-only tasks [1]). ",
+        "bbox": [
+            173,
+            665,
+            823,
+            694
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Expert pruning (Appendix E.4). We show using simple heuristics we can prune down to modalityspecific experts for unimodal forward passes, thus avoiding expert collapse under unimodal batches. ",
+        "bbox": [
+            174,
+            700,
+            823,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Training on public data (Appendix E.6) The majority of LIMoE models were trained on proprietary data [16]. We show that LIMoE works similarly well on publically available data, retaining performance improvements against a comparable dense model. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            776
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Model Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            800,
+            334,
+            818
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we explore some of the internal workings of LIMoE. We use simple B/32 and B/16 models with 8 experts, and the large H/14 with 32. See Appendix F for further details and experiments. ",
+        "bbox": [
+            174,
+            834,
+            825,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Multimodal experts arise (Appendix F.1). Aside from encouraging diversity, we do not explicitly enforce experts to specialize. Nonetheless, we observe the emergence of both modality-specific experts, and multimodal experts which process both images and texts (per-expert distributions in F.1). ",
+        "bbox": [
+            174,
+            868,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Qualitative analysis (Appendix F.2). We analyse some example data and show a clear emergence of semantically meaningful experts. With images for instance, some experts specialize on lower level features (colours, lines) while others on more complex features (faces and text), see Figure 2. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "BPR ranking (Appendix F.5). The local loss encourages high max-routing weights for text, and BPR ranks according to this. We show however that this does not mean text is always prioritised first: Especially in later layers, the model often prioritises important image patches over text. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            181
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            203,
+            316,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Unimodal, task-specific neural networks have long been researched, with increasing convergence towards Transformer-based architectures [23, 26] for both NLP [27] and Computer Vision [13, 28, 29]. Multimodal models aim to process multiple types of data using a single neural network. ",
+        "bbox": [
+            174,
+            234,
+            825,
+            277
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Many approaches “fuse” modalities [30, 31, 32, 33] to tackle inherently multimodal tasks. LIMoE is more similar to approaches which do not do that, and still operate as unimodal feature extractors. Some co-train on distinct tasks [34, 35, 36, 22] without aligning or fusing representations—effectively sharing weights across tasks—whereas others include both unimodal aspects and fused multimodal aspects for functionality in both contexts [37]. ",
+        "bbox": [
+            174,
+            284,
+            825,
+            353
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We build on deep Sparse Mixture of Experts models, which have been studied independently in Computer Vision [1, 2] and NLP [14, 3, 8], typically in the context of transfer learning. These models use a learned gating mechanism whereby only a subset of $K$ experts out of $E \\gg K$ are activated for a given input. Many works aim to improve the gating mechanism itself, by making it differentiable [38], reformulating as a linear assignment task [39] or even swapping it out for a simple hashing algorithm [40]. MoE models have also been studied for multitask learning [38], with per-task routers [6] but a shared pool of experts. To our knowledge, sparse models have not been explored for multimodal learning. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            470
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A large body of research exists on contrastive learning, usually in self-supervised [41] but also in supervised regimes [42]. Multimodal contrastive learning trains on aligned data from multiple modalities. Originally studied for medical images and reports [11], it was recently scaled to noisy web data [7, 10], where strong image-text alignments enabled performant image classification and cross-modal image-text retrieval without finetuning on downstream data. Follow up works improved upon this significantly by scaling up and using pretrained models [18, 16] and multitask training with generative modelling [25] or other vision tasks [43]. These works use unimodal models which separately process image and text data; we are not aware of previous research using a single model to process both images and texts for contrastive learning, neither with dense nor with sparse models. ",
+        "bbox": [
+            174,
+            477,
+            825,
+            602
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusions and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            622,
+            457,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have presented LIMoE, the first multimodal sparse mixture of experts model. We uncovered new failure modes specific to this setup and proposed entropy based auxiliary losses which stabilises training and results in highly performant models. It works across many model scales, with average improvements over FLOP-matched dense baselines of $+ 1 0 . 2 \\%$ zero-shot accuracy. When scaled to a large H/14 model, we achieve $8 4 . 1 \\%$ accuracy, competitive with current SOTA approaches. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            726
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Societal impact and limitations: The potential harms of large scale models [44], contrastive models [7] and web-scale multimodal data [45] also carry over here, as LIMoE does not explicitly address them. On the other hand, it has been shown that pruning models tends to cause low-resource groups to be forgotten [46], causing performance to disproportionally drop for some subgroups. This would be worth considering for our expert-pruning experiments, but by analogue, the ability to scale models with experts that can specialize deeply may result in better performance on underrepresented groups. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            815
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Environmentally speaking, training large models is costly, though efforts are made to use efficient datacenters and offset emitted $\\mathrm { C O } _ { 2 }$ . Prior works however show that most environmental impact occurs during model inference, and that MoEs are significantly more efficient in that regard [47]; LIMoE is naturally a good candidate for efficient, large-scale multimodal foundation models. ",
+        "bbox": [
+            174,
+            820,
+            825,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Future work: There are many interesting directions from here. The routing interference with multiple modalities still is not fully understood. In general, conclusions from applications of MoEs to NLP have not carried over perfectly to Vision, and vice-versa, and here we see again different behaviour between images and text. Naturally, extensions to more modalities should be explored; even with only two we see fascinating interactions between different data types and the routing algorithms, and that will only get more difficult, and interesting, with more modalities. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There are always more modalities to learn, and larger models to build: sparse models provide a very natural way to scale up while juggling very different tasks and data, and we look forward to seeing more research in this area. ",
+        "bbox": [
+            174,
+            154,
+            823,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            214,
+            367,
+            232
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We first thank Andreas Steiner, Xiao Wang and Xiaohua Zhai, who led early explorations into dense single-tower models for contrastive multimodal learning, and also were instrumental in providing data access. We also thank Andreas Steiner, and Douglas Eck, for early feedback on the paper. We thank André Susano Pinto, Maxim Neumann, Barret Zoph, Liam Fedus, Wei Han and Josip Djolonga for useful discussions, and Erica Moreira and Victor Gomes for help scaling up to LIMoE-H/14. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            315
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Carlos Riquelme, Joan Puigcerver, Basil Mustafa, Maxim Neumann, Rodolphe Jenatton, André Susano Pinto, Daniel Keysers, and Neil Houlsby. Scaling vision with sparse mixture of experts. In Advances in Neural Information Processing Systems. Curran Associates, Inc., 2021.   \n[2] Yuxuan Lou, Fuzhao Xue, Zangwei Zheng, and Yang You. Cross-token modeling with conditional computation, 2022.   \n[3] Dmitry Lepikhin, HyoukJoong Lee, Yuanzhong Xu, Dehao Chen, Orhan Firat, Yanping Huang, Maxim Krikun, Noam Shazeer, and Zhifeng Chen. Gshard: Scaling giant models with conditional computation and automatic sharding. In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021. OpenReview.net, 2021.   \n[4] Barret Zoph, Irwan Bello, Sameer Kumar, Nan Du, Yanping Huang, Jeff Dean, Noam Shazeer, and William Fedus. St-moe: Designing stable and transferable sparse expert models, 2022.   \n[5] Mark Collier, Efi Kokiopoulou, Andrea Gesmundo, and Jesse Berent. Routing networks with co-training for continual learning, 2020.   \n[6] Jiaqi Ma, Zhe Zhao, Xinyang Yi, Jilin Chen, Lichan Hong, and Ed H. Chi. Modeling task relationships in multi-task learning with multi-gate mixture-of-experts. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2018, London, UK, August 19-23, 2018. ACM, 2018.   \n[7] Alec Radford, Jong Wook Kim, Chris Hallacy, Aditya Ramesh, Gabriel Goh, Sandhini Agarwal, Girish Sastry, Amanda Askell, Pamela Mishkin, Jack Clark, Gretchen Krueger, and Ilya Sutskever. Learning transferable visual models from natural language supervision. In ICML, Proceedings of Machine Learning Research. PMLR, 2021.   \n[8] William Fedus, Barret Zoph, and Noam Shazeer. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. JMLR, 23(120), 2022.   \n[9] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR 2009), 20-25 June 2009, Miami, Florida, USA. IEEE Computer Society, 2009.   \n[10] Chao Jia, Yinfei Yang, Ye Xia, Yi-Ting Chen, Zarana Parekh, Hieu Pham, Quoc V. Le, Yun-Hsuan Sung, Zhen Li, and Tom Duerig. Scaling up visual and vision-language representation learning with noisy text supervision. In Proceedings of the 38th International Conference on Machine Learning, ICML 2021, 18-24 July 2021, Virtual Event, Proceedings of Machine Learning Research. PMLR, 2021.   \n[11] Yuhao Zhang, Hang Jiang, Yasuhide Miura, Christopher D. Manning, and Curtis P. Langlotz. Contrastive learning of medical visual representations from paired images and text. CoRR, 2020.   \n[12] Taku Kudo and John Richardson. Sentencepiece: A simple and language independent subword tokenizer and detokenizer for neural text processing. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, EMNLP 2018: System Demonstrations, Brussels, Belgium, October 31 - November 4, 2018. Association for Computational Linguistics, 2018.   \n[13] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. ICLR, 2021.   \n[14] Noam Shazeer, Azalia Mirhoseini, Krzysztof Maziarz, Andy Davis, Quoc Le, Geoffrey Hinton, and Jeff Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer. In 5th International Conference on Learning Representations, ICLR 2017, 2017.   \n[15] Thomas M Cover. Elements of information theory. John Wiley & Sons, 1999.   \n[16] Xiaohua Zhai, Xiao Wang, Basil Mustafa, Andreas Steiner, Daniel Keysers, Alexander Kolesnikov, and Lucas Beyer. Lit: Zero-shot transfer with locked-image text tuning. CVPR, 2021.   \n[17] Xiaohua Zhai, Alexander Kolesnikov, Neil Houlsby, and Lucas Beyer. Scaling vision transformers. CVPR, 2021.   \n[18] Hieu Pham, Zihang Dai, Golnaz Ghiasi, Kenji Kawaguchi, Hanxiao Liu, Adams Wei Yu, Jiahui Yu, Yi-Ting Chen, Minh-Thang Luong, Yonghui Wu, Mingxing Tan, and Quoc V. Le. Combined scaling for open-vocabulary image classification, 2022. ",
+        "bbox": [
+            173,
+            83,
+            828,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[19] Richard Socher, Milind Ganjoo, Christopher D Manning, and Andrew Ng. Zero-shot learning through cross-modal transfer. In Advances in Neural Information Processing Systems. Curran Associates, Inc., 2013. ",
+        "bbox": [
+            171,
+            92,
+            823,
+            130
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Tsung-Yi Lin, Michael Maire, Serge J. Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Doll’ar, and C. Lawrence Zitnick. Microsoft COCO: common objects in context. In Computer Vision - ECCV 2014 - 13th European Conference, Zurich, Switzerland, September 6-12, 2014, Proceedings, Part V, Lecture Notes in Computer Science. Springer, 2014. ",
+        "bbox": [
+            173,
+            140,
+            826,
+            193
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Mitchell Wortsman, Gabriel Ilharco, Samir Yitzhak Gadre, Rebecca Roelofs, Raphael Gontijo Lopes, Ari S. Morcos, Hongseok Namkoong, Ali Farhadi, Yair Carmon, Simon Kornblith, and Ludwig Schmidt. Model soups: averaging weights of multiple fine-tuned models improves accuracy without increasing inference time. CoRR, 2022. ",
+        "bbox": [
+            174,
+            202,
+            826,
+            253
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Scott Reed, Konrad Zolna, Emilio Parisotto, Sergio Gomez Colmenarejo, Alexander Novikov, Gabriel Barth-Maron, Mai Gimenez, Yury Sulsky, Jackie Kay, Jost Tobias Springenberg, Tom Eccles, Jake Bruce, Ali Razavi, Ashley Edwards, Nicolas Heess, Yutian Chen, Raia Hadsell, Oriol Vinyals, Mahyar Bordbar, and Nando de Freitas. A generalist agent, 2022. ",
+        "bbox": [
+            173,
+            263,
+            826,
+            315
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] 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. Curran Associates, Inc., 2017. ",
+        "bbox": [
+            171,
+            325,
+            821,
+            364
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Hugo Touvron, Andrea Vedaldi, Matthijs Douze, and Herv’e J’egou. Fixing the train-test resolution discrepancy. In Advances in Neural Information Processing Systems (NeurIPS), 2019. ",
+        "bbox": [
+            171,
+            373,
+            821,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Jiahui Yu, Zirui Wang, Vijay Vasudevan, Legg Yeung, Mojtaba Seyedhosseini, and Yonghui Wu. Coca: Contrastive captioners are image-text foundation models, 2022. ",
+        "bbox": [
+            173,
+            410,
+            823,
+            436
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In NAACL, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. ",
+        "bbox": [
+            171,
+            446,
+            823,
+            486
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. ACM Comput. Surv., 2022. ",
+        "bbox": [
+            171,
+            494,
+            823,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Ze Liu, Yutong Lin, Yue Cao, Han Hu, Yixuan Wei, Zheng Zhang, Stephen Lin, and Baining Guo. Swin transformer: Hierarchical vision transformer using shifted windows. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2021. ",
+        "bbox": [
+            173,
+            531,
+            823,
+            571
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Kishaan Jeeveswaran, Senthilkumar Kathiresan, Arnav Varma, Omar Magdy, Bahram Zonooz, and Elahe Arani. A comprehensive study of vision transformers on dense prediction tasks. In Proceedings of the 17th International Joint Conference on Computer Vision, Imaging and Computer Graphics Theory and Applications, VISIGRAPP 2022, Volume 4: VISAPP, Online Streaming, February 6-8, 2022. SCITEPRESS, 2022. ",
+        "bbox": [
+            174,
+            580,
+            826,
+            643
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Hao Tan and Mohit Bansal. Lxmert: Learning cross-modality encoder representations from transformers. In EMNLP, 2019. ",
+        "bbox": [
+            173,
+            655,
+            823,
+            681
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Weijie Su, Xizhou Zhu, Yue Cao, Bin Li, Lewei Lu, Furu Wei, and Jifeng Dai. Vl-bert: Pre-training of generic visual-linguistic representations. In ICLR, 2020. ",
+        "bbox": [
+            174,
+            690,
+            823,
+            717
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. Vilbert: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. In NeurIPS. Curran Associates, Inc., 2019. ",
+        "bbox": [
+            173,
+            727,
+            823,
+            753
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, and Kai-Wei Chang. Visualbert: A simple and performant baseline for vision and language. CoRR, 2019. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            790
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Valerii Likhosherstov, Anurag Arnab, Krzysztof Choromanski, Mario Lucic, Yi Tay, Adrian Weller, and Mostafa Dehghani. Polyvit: Co-training vision transformers on images, videos and audio. CoRR, 2021. ",
+        "bbox": [
+            173,
+            799,
+            825,
+            827
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] Hassan Akbari, Liangzhe Yuan, Rui Qian, Wei-Hong Chuang, Shih-Fu Chang, Yin Cui, and Boqing Gong. Vatt: Transformers for multimodal self-supervised learning from raw video, audio and text. NeurIPS, 2021. ",
+        "bbox": [
+            173,
+            835,
+            826,
+            863
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] Qing Li, Boqing Gong, Yin Cui, Dan Kondratyuk, Xianzhi Du, Ming-Hsuan Yang, and Matthew Brown. Towards a unified foundation model: Jointly pre-training transformers on unpaired images and text. arXiv preprint arXiv:2112.07074, 2021. ",
+        "bbox": [
+            174,
+            873,
+            828,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Jianfeng Wang, Xiaowei Hu, Zhe Gan, Zhengyuan Yang, Xiyang Dai, Zicheng Liu, Yumao Lu, and Lijuan Wang. UFO: A unified transformer for vision-language representation learning. CoRR, 2021. ",
+        "bbox": [
+            169,
+            92,
+            825,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[38] Hussein Hazimeh, Zhe Zhao, Aakanksha Chowdhery, Maheswaran Sathiamoorthy, Yihua Chen, Rahul Mazumder, Lichan Hong, and Ed H. Chi. Dselect-k: Differentiable selection in the mixture of experts with applications to multi-task learning. In Advances in Neural Information Processing Systems 34: Annual Conference on Neural Information Processing Systems 2021, NeurIPS 2021, December 6-14, 2021, virtual, 2021. ",
+        "bbox": [
+            173,
+            127,
+            825,
+            190
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[39] Mike Lewis, Shruti Bhosale, Tim Dettmers, Naman Goyal, and Luke Zettlemoyer. BASE layers: Simplifying training of large, sparse models. In Proceedings of the 38th International Conference on Machine Learning, ICML 2021, 18-24 July 2021, Virtual Event, Proceedings of Machine Learning Research. PMLR, 2021. ",
+        "bbox": [
+            173,
+            200,
+            825,
+            251
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[40] Stephen Roller, Sainbayar Sukhbaatar, Arthur Szlam, and Jason Weston. Hash layers for large sparse models. In Advances in Neural Information Processing Systems 34: Annual Conference on Neural Information Processing Systems 2021, NeurIPS 2021, December 6-14, 2021, virtual, 2021. ",
+        "bbox": [
+            173,
+            261,
+            825,
+            300
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[41] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey E. Hinton. A simple framework for contrastive learning of visual representations. In Proceedings of the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, Proceedings of Machine Learning Research. PMLR, 2020. ",
+        "bbox": [
+            173,
+            308,
+            825,
+            359
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[42] Prannay Khosla, Piotr Teterwak, Chen Wang, Aaron Sarna, Yonglong Tian, Phillip Isola, Aaron Maschinot, Ce Liu, and Dilip Krishnan. Supervised contrastive learning. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020. ",
+        "bbox": [
+            174,
+            368,
+            826,
+            420
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[43] Lu Yuan, Dongdong Chen, Yi-Ling Chen, Noel Codella, Xiyang Dai, Jianfeng Gao, Houdong Hu, Xuedong Huang, Boxin Li, Chunyuan Li, Ce Liu, Mengchen Liu, Zicheng Liu, Yumao Lu, Yu Shi, Lijuan Wang, Jianfeng Wang, Bin Xiao, Zhen Xiao, Jianwei Yang, Michael Zeng, Luowei Zhou, and Pengchuan Zhang. Florence: A new foundation model for computer vision. CoRR, 2021. ",
+        "bbox": [
+            173,
+            429,
+            825,
+            481
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Rishi Bommasani, Drew A. Hudson, Ehsan Adeli, Russ Altman, Simran Arora, Sydney von Arx, Michael S. Bernstein, Jeannette Bohg, Antoine Bosselut, Emma Brunskill, Erik Brynjolfsson, Shyamal Buch, Dallas Card, Rodrigo Castellon, Niladri S. Chatterji, Annie S. Chen, Kathleen Creel, Jared Quincy Davis, Dorottya Demszky, Chris Donahue, Moussa Doumbouya, Esin Durmus, Stefano Ermon, John Etchemendy, Kawin Ethayarajh, Li Fei-Fei, Chelsea Finn, Trevor Gale, Lauren Gillespie, Karan Goel, Noah D. Goodman, Shelby Grossman, Neel Guha, Tatsunori Hashimoto, Peter Henderson, John Hewitt, Daniel E. Ho, Jenny Hong, Kyle Hsu, Jing Huang, Thomas Icard, Saahil Jain, Dan Jurafsky, Pratyusha Kalluri, Siddharth Karamcheti, Geoff Keeling, Fereshte Khani, Omar Khattab, Pang Wei Koh, Mark S. Krass, Ranjay Krishna, Rohith Kuditipudi, and et al. On the opportunities and risks of foundation models. CoRR, 2021. ",
+        "bbox": [
+            174,
+            488,
+            826,
+            604
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Abeba Birhane, Vinay Uday Prabhu, and Emmanuel Kahembwe. Multimodal datasets: misogyny, pornography, and malignant stereotypes. CoRR, 2021. ",
+        "bbox": [
+            173,
+            613,
+            821,
+            640
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[46] Sara Hooker, Nyalleng Moorosi, Gregory Clark, Samy Bengio, and Emily L. Denton. Characterising bias in compressed models. ArXiv, abs/2010.03058, 2020. ",
+        "bbox": [
+            173,
+            647,
+            821,
+            674
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[47] David A. Patterson, Joseph Gonzalez, Quoc V. Le, Chen Liang, Lluis-Miquel Munguia, Daniel Rothchild, David R. So, Maud Texier, and Jeff Dean. Carbon emissions and large neural network training. CoRR, 2021. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            722
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[48] 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. J. Mach. Learn. Res., 2020. ",
+        "bbox": [
+            173,
+            731,
+            823,
+            770
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[49] Christoph Schuhmann, Richard Vencu, Romain Beaumont, Robert Kaczmarczyk, Clayton Mullis, Aarush Katta, Theo Coombes, Jenia Jitsev, and Aran Komatsuzaki. LAION-400M: open dataset of clip-filtered 400 million image-text pairs. CoRR, abs/2111.02114, 2021. ",
+        "bbox": [
+            173,
+            779,
+            821,
+            818
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[50] Steven Bird, Edward Loper, and Ewan Klein. NLTK: the natural language toolkit. In ACL 2006, 21st International Conference on Computational Linguistics and 44th Annual Meeting of the Association for Computational Linguistics. The Association for Computer Linguistics, 2006. ",
+        "bbox": [
+            173,
+            827,
+            823,
+            866
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/X6dEqXIsEW/X6dEqXIsEW.md

@@ -0,0 +1,222 @@
+# On the Planning Abilities of Large Language Models : A Critical Investigation
+
+Karthik Valmeekam School of Computing & AI Arizona State University Tempe. kvalmeek@asu.edu
+
+Matthew Marquez School of Computing & AI Arizona State University, Tempe. mmarqu22@asu.edu
+
+Sarath Sreedharan∗ Department of Computer Science, Colorado State University, Fort Collins. sarath.sreedharan@colostate.edu
+
+Subbarao Kambhampati School of Computing & AI Arizona State University, Tempe. rao@asu.edu
+
+# Abstract
+
+Intrigued by the claims of emergent reasoning capabilities in LLMs trained on general web corpora, in this paper, we set out to investigate their planning capabilities. We aim to evaluate (1) the effectiveness of LLMs in generating plans autonomously in commonsense planning tasks and (2) the potential of LLMs as a source of heuristic guidance for other agents (AI planners) in their planning tasks. We conduct a systematic study by generating a suite of instances on domains similar to the ones employed in the International Planning Competition and evaluate LLMs in two distinct modes: autonomous and heuristic. Our findings reveal that LLMs’ ability to generate executable plans autonomously is rather limited, with the best model (GPT-4) having an average success rate of ${ \sim } 1 2 \%$ across the domains. However, the results in the heuristic mode show more promise. In the heuristic mode, we demonstrate that LLM-generated plans can improve the search process for underlying sound planners and additionally show that external verifiers can help provide feedback on the generated plans and back-prompt the LLM for better plan generation.
+
+# 1 Introduction
+
+It would be no exaggeration to say that transformer-based large language models (LLMs) have revolutionized the field of natural language processing (NLP). Kicked off by the advances presented by the GPT- $\mathbf { X }$ models developed by OpenAI [27], these types of language models currently provide state-of-the-art performance in many of the standard NLP tasks. Although LLMs were originally developed mostly to do word sequence completion tasks, with no guarantees about the completion beyond its coherence, there have been increasing claims and anecdotal evidence that they have other emergent capabilities that are not normally associated with sequence completion. Indeed, the hints of such emergent capabilities has started a veritable land rush, with researchers probing (prompting) and studying LLM behavior almost as if they were artificial organisms (c.f. [16]). Of particular interest to us in this paper is the thread of efforts that aim to investigate (and showcase) reasoning abilities of LLMs–including commonsense reasoning [35, 29, 7], logical reasoning [33], and even ethical reasoning [15]. The macro-tenor of the drumbeat of these works has been suggesting that LLM’s are indeed capable of doing such kinds of reasoning [19, 37, 4].
+
+One type of reasoning task that has been well studied in the AI community is planning and sequential decision making. At its simplest, planning involves developing a course of actions (policy) which when executed takes the agent to a desired state of the world. Planning has generally been studied primarily as an inference on world and reward models–whether specified by humans or learned by the agent by interacting with its world. In this paper, we are interested in seeing what planning abilities, if any, LLMs may already have, given their high capacity functions (with billions of tunable parameters) trained on web-scale corpora. Specifically, we are interested in answering two broad questions:
+
+1. How effective are LLMs by themselves in generating simple plans in commonsense planning tasks (of the type that humans are generally quite good at)?   
+2. How good are LLMs in being a source of heuristic guidance for other agents in their planning tasks?
+
+Notice that in theory, it is possible for LLMs to be very effective as idea generators for external sound planners or humans in the loop in computer-supported cooperative work scenarios, while themselves being very bad at generating plans that are guaranteed to be correct. This is especially likely because the chief power of LLMs comes from their pattern-finding abilities than from firstprinciples simulations over world models. Compared to a planner that is guaranteed to be correct in a narrow set of domains, LLMs may likely be good at generating plausible (but not guaranteed to be correct) plan heuristics/suggestions in many more domains.
+
+To investigate these questions in a systematic rather than anecdotal manner, we generate a suite of planning problem instances 2 based on the kinds of domains employed in the International Planning Competition [14]. To eliminate the subjective aspect of analysis that forms the core part of many earlier efforts on evaluating the reasoning capabilities of LLMs, we automate the evaluation by leveraging models and tools from the automated planning community. The evaluation itself is done in two modes (shown in Figure 1). In the first “autonomous" mode, LLMs are used standalone, and we directly assess the quality and correctness of plans they generate. As we shall see, the results in the autonomous mode are pretty bleak. On an average, only about $12 \%$ of the plans that the best LLM (GPT-4) generates are actually executable without errors and reach their goals. We will show that the choice of the specific LLM (we have tested the family of GPT LLMs including GPT-4 [25], GPT-3.5 [24], InstructGPT-3.5, InstructGPT-3 [26] and GPT-3 [3]), as well as fine tuning does not seem to have a major effect on this dismal performance. We also show that the performance deteriorates further if the names of the actions and objects in the domain are obfuscated–a change that doesn’t in anyway affect the performance of the standard AI planners. To shed further light on the performance of GPT4, we present an evaluation of the plans it generates under a series of more relaxed (more forgiving) executability conditions. Further, we provide a human baseline for the simplest domain in our set of domains, by presenting the planning instances to human subjects (through IRB-approved studies) and evaluating the quality and correctness of their plans. These results are substantially better than those of LLMs–confirming that LLMs can’t plan even in a simple common sense domain in the autonomous mode. In the second “heuristic" mode, the plans produced by LLMs are given as input to an automated planner working off of a correct domain model to check whether the LLM’s plans help with the search process of the underlying planner to come up with correct plans. Specifically we show that a well known automated planner called LPG [6], that uses local search to locate and remove flaws in a candidate plan to make it correct, is able to repair the LLM plans with relative ease. We compare the LLM+LPG combination with two baselines, one where an empty plan is used as the seed plan for the LPG and two, where a random plan is provided as the seed plan to the LPG. We show that the average search steps by the LLM+LPG combination is much lesser than both the baselines, thereby revealing that LLMs’ plans are indeed helping with the search process of the underlying planner. Further, instead of having LPG correct the plans, we use an external verifier, VAL [11], to point out the errors in the LLM-generated plans and back-prompt the LLM for a new plan with this feedback. We show that this repeated interaction indeed improves the plan correctness in common-sense domains. Overall, our findings demonstrate that, with respect to planning, LLMs’ perform poorly in the autonomous mode but the generated plans can help AI planners in the search process or can be given to external verifiers and back-prompt the LLM for better plans. In this paper, we first present an overview of the related work. Following that, we describe the necessary background and the prompt generation pipeline. Finally, we provide the results and analysis of various experiments undertaken in both autonomous and heuristic evaluation modes.
+
+![](images/89c4ff73d93d4e9706caa68cf963311cc1fc37c13740df2131635c53ad85a188.jpg)  
+Figure 1: The diagrammatic overview of the two modes of LLMs for planning.
+
+# 2 Related Work
+
+In this work, we look at LLMs’ planning capabilities when the domain is given as part of the prompt (as is the standard practice in automated planning [8]). Our evaluation focuses on zero-shot (just domain and problem specification), and few-shot (example problems with plans) modes. There have been a few works that looked at the planning capabilities of LLMs. Most of them, such as [12, 2] focus on commonsense domains/tasks (e.g. moving things in kitchens, wedding/menu planning etc.) and thus evaluate LLMs in a mode wherein the prompt doesn’t include any information about the specific domain. Plans generated in that way are hard to evaluate as they are not directed at any plan executor and the humans often wind up giving the benefit of doubt for a plausible–but not actually executable–plan. This is why in SayCan [2], where executability is critical, they try to filter out/interpret the LLM plans in terms of the skills/actions that are actually available to the executor. While SayCan does this in a rather convoluted way that requires access to the internal log probabilities of the LLM, our approach simplifies this by specifying the domain as part of the prompt. In all our experiments, we found that LLMs only use the actions listed as part of the domain specification.
+
+One other mode of evaluation of planning capabilities in the literature involves the user incrementally interacting with the LLM, and re-prompting it to point out flaws in its plans, with the hope that the LLM eventually reaches an executable plan [13, 39, 28]. Such evaluations are notorious for their Clever Hans effect [1] with the actual planning being done by the humans in the loop rather than the LLMs themselves. We thus separate our evaluation into two modes–autonomous and as assistants to external planners/reasoners. There have also been efforts which mostly depended on LLMs as “translators" of natural language problem/goal specification into formal specifications, which are then thrown over to sound external planners [38, 21]. Such efforts don’t shed any light on the internal planning capabilities of the LLMs themselves, as our evaluations in autonomous and assistive modes do. Finally, after our initial study and benchmark were made public, other groups did parallel studies that largely corroborate our results on the ineffectiveness of LLMs in finding executable plans [32, 21].
+
+Taking a broader perspective, making plans in the world involves (1) discovering actions (and their precondition/effect causal dependencies), and (2) sequencing an appropriate subset of available/discovered actions to achieve the agent’s goals. The former requires broad knowledge about actions available in the world and their individual effects, while the latter requires deep drilling-down over a given set of actions to ensure that all goals are supported (causal chaining) without any undesirable interactions. LLMs have an edge on the former–they do indeed have web-scale broad knowledge! As we shall see however, they are very bad at the second phase of developing valid interaction-free plans (in part, because LLMs don’t have the ability to do combinatorial search). Most cases in literature (as outlined in [18]) where LLMs are claimed to have "planned" turn out, upon close examination, to be instances of phase 1–your wedding plans, recipe plans etc.–where you are either using a very forgiving plan correctness criterion, or the phase 2 is vacuous. Standard AI planners–on the other hand–assume that the discovery part is done and handed down as a compact domain model, and focus mostly on the second part: selecting among known actions to establish causal chains and sequencing them to make them interaction free. In this sense, LLMs and AI planners can be complementary, as we have shown in this paper–with the former helping with phase 1–either with a candidate/approximate plan or domain model–and the latter with phase 2.
+
+# 3 Prompt Generation for Classical Planning Problems
+
+# 3.1 Background
+
+Given that we are interested in investigating the basic reasoning about actions and change problem, we want to look at the most fundamental planning formalism first, namely the goal-directed deterministic planning problem. Colloquially referred to as classical planning problem, these problem classes consist of a problem domain, an initial state and a goal state. The problem domain consists of a set of fluents which correspond to predicates with some arity and a set of actions. The state-space for the planning problem is defined by the possible truth assignment over the predicates. Each action consists of preconditions and effects where preconditions is a set of predicates that describe when an action can be executed and effects are set of predicates that describe what happens when an action is executed. The effects can further consist of add effects, which is the set of predicates that will be set true by the action, and delete effects, which is the set of predicates that will be set false. The solution for a planning problem is a sequence of actions, or a plan, that when applied in the initial state will result in a state where the goal conditions are satisfied. A standard representation to specify such kind of planning problems is the Planning Definition and Domain Language (PDDL) [22]. Below is a snippet of an action from a popular benchmark problem called Blocksworld, in PDDL. The action corresponds to picking up a block in that domain.
+
+(:action pickup :parameters (?ob) :precondition (and (clear ?ob) (on-table ?ob) (arm-empty)) :effect (and (holding ?ob) (not (clear ?ob)) (not (on-table ?ob)) (not (arm-empty))))
+
+A more detailed description on classical planning problems is provided in Appendix A.1. We now will describe how we generate the prompts that are given to the LLMs.
+
+# 3.2 Prompt Generation
+
+![](images/642747863f0ac95f99387bb3732e05cc831ea3428dac9efab84f28bb5198f230.jpg)  
+Figure 2: The diagrammatic overview of the prompt generation pipeline. The prompt configurations for the different experiments are generated from PDDL domain files and are modified with an example generator and natural language translator as needed depending on the experiment requirements.
+
+Prompt Configurations: We have developed a suite of unique planning problems to test LLMs’ abilities to generate plans. We have multiple prompt configurations based on this suite of problems, varying in both the method of presentation as well as number of examples given to the LLM. In particular, we use two methods of presentation, natural language and PDDL, as well as two different methods of providing examples, zero shot (with no examples provided) and one shot (with an example provided), giving us four different configuration combinations for our experiments.
+
+Within a prompt, LLMs are first provided with a lifted domain description. For one shot configurations, the prompt additionally contains an example instance of a planning problem (consisting of a description of the initial state and the goal) and the corresponding plan (which ends with a tag, referred to as the plan-end tag, that denotes the end of the plan). All prompts end with a planning problem description. The text generated by the LLM until the plan-end tag is used as the candidate for extracting the plan. If the extractor cannot reasonably extract an instance, it is marked as incorrect.
+
+Table 1: Results of GPT-4, GPT-3.5 (popularly known as ChatGPT), Instruct-GPT3.5, Instruct-GPT3 (text-davinci-002) and GPT3 (davinci) for the Plan Generation task with prompts in natural language.   
+
+<table><tr><td rowspan="2">Domain</td><td rowspan="2">Method</td><td colspan="5">Instances correct</td></tr><tr><td>GPT-4</td><td>GPT-3.5</td><td>I-GPT3.5</td><td>I-GPT3</td><td>GPT-3</td></tr><tr><td rowspan="3">Blocksworld (BW)</td><td>One-shot</td><td>206/600 (34.3%)</td><td>37/600 (6.1%)</td><td>54/600 (9%)</td><td>41/600 (6.8%)</td><td>6/600 (1%)</td></tr><tr><td>Zero-shot</td><td>210/600 (34.6%)</td><td>8/600 (1.3%)</td><td>1</td><td>1</td><td>1</td></tr><tr><td>COT</td><td>214/600 (35.6%)</td><td>=</td><td></td><td>1</td><td></td></tr><tr><td rowspan="2">Logistics Domain</td><td>One-shot</td><td>28/200 (14%)</td><td>1/200 (0.5%)</td><td>6/200 (3%)</td><td>3/200 (1.5%)</td><td></td></tr><tr><td>Zero-shot</td><td>15/200 (7.5%)</td><td>1/200 (0.5%)</td><td>=</td><td>-</td><td>1</td></tr><tr><td rowspan="3">Mystery BW (Deceptive)</td><td>One-shot</td><td>26/600 (4.3%)</td><td>0/600 (0%)</td><td>4/600 (0.6%)</td><td>14/600</td><td>0/600</td></tr><tr><td>Zero-shot</td><td>1/600 (0.16%)</td><td>0/600 (0%)</td><td>-</td><td>(2.3%) 1</td><td>(0%) 1</td></tr><tr><td>COT</td><td>54/600 (9%)</td><td></td><td>-</td><td>-</td><td>1</td></tr><tr><td rowspan="2">Mystery BW (Randomized)</td><td>One-shot</td><td>12/600 (2%)</td><td>0/600 (0%)</td><td>5/600 (0.8%)</td><td>5/600 (0.8%)</td><td>1/600</td></tr><tr><td>Zero-shot</td><td>0/600 (0%)</td><td>0/600 (0%)</td><td>-</td><td>-</td><td>(0.1%) -</td></tr></table>
+
+The prompt is either formatted in natural langauge or PDDL. Natural language prompts utilize complete natural language sentences to describe feasible actions in the domain. Initial conditions are also reported as complete sentences. Plans in the natural language setting take the form of a series of commands such as "stack the orange block on top of the blue block". As implied by the name, PDDL prompts format all elements (domain description, initial state, goal state, and plans) using PDDL. We point the reader to the supplementary material for examples on each of these prompt configurations.
+
+Chain of Thought Prompting: In addition to the four experiments above, we look at a fifth experiment using a state tracking chain of thought prompting technique in a natural language one shot setting. Within this configuration, we provide an annotated example where each action is annotated with the state prior to the action, the reason for why the action is applicable in the prior state, and the resulting state after applying the action. After the example, a meta-explanation about plan correctness is provided. The LLM is then asked to return a response making the same state tracking and justification annotations that were included in the example.
+
+Prompt Generation Pipeline: We’ve developed a prompt generation pipeline (visualized in Figure 2) that accepts PDDL domain files as input and outputs prompts that follow the experiments described above. The prompt generation component takes care of creating the set of PDDL problems to be solved for all experiments. Following that, examples are added to the prompt in one shot experiments. While our setup utilizes a planner during example generation, any example generation technique could be used here so long as the examples generated are valid plans. In the state tracking experiment, we also have developed a component to add justification annotations for examples so that the examples reflect what we expect of the LLM. The last step before finishing is translation: since problems at this point are currently in PDDL, prompts for all natural language experiments (whether an example was added or not) need to be translated into natural language. We utilize a domain-specific translator to do so.
+
+# 4 Evaluating Planning Capabilities of LLMs in Autonomous Mode
+
+In the autonomous mode, we treat the LLM as an automated planner and perform a single run of the dataset on the LLMs for each domain and prompt configuration. In this mode, the plan generated by the LLM is back-translated from natural language to forms that can be used by external plan validators. For each domain, we perform template-based translation to translate between PDDL and natural language for the natural language prompt configurations. We use VAL [11] to evaluate the translated plan with the corresponding domain and problem file. Our evaluation here primarily focuses on the GPT family of LLMs. We tested GPT-4 [25] and GPT-3.5 (commonly known as Chat-GPT) [24] on all the prompt configurations while we tested the older versions of GPT (namely, Instruct-GPT3 and GPT3) on one-shot natural language prompts across the domains. We set the temperature for all models to be 0, thereby making them deterministic. In this section, we detail the evaluation of LLMs on these domains and prompt configurations. We would like to point the reader to the Appendix for example prompts.
+
+Table 2: Results of GPT-4 and GPT-3.5 (popularly known as ChatGPT) for the Plan Generation task with one or zero examples in the prompt by directly providing the domain and problem in PDDL.   
+
+<table><tr><td rowspan="2">Domain</td><td rowspan="2">Method</td><td colspan="2">Instances correct</td></tr><tr><td>GPT-4</td><td>GPT-3.5</td></tr><tr><td rowspan="2">Blocksworld (BW)</td><td>One-shot</td><td>75/600 (12.5%)</td><td>12/600 (2%)</td></tr><tr><td>Zero-shot</td><td>106/600 (17.6%)</td><td>12/600 (2%)</td></tr><tr><td rowspan="2">Logistics Domain</td><td>One-shot</td><td>28/200 (14%)</td><td>1/200 (0.5%)</td></tr><tr><td>Zero-shot</td><td>11/200 (5.5%)</td><td>0/200 (0%)</td></tr><tr><td rowspan="2">Mystery BW (Deceptive)</td><td>One-shot</td><td>17/600 (2.8%)</td><td>1/600 (0.1%)</td></tr><tr><td>Zero-shot</td><td>3/600 (0.5%)</td><td>0/600 (0%)</td></tr></table>
+
+Evaluation of LLMs on the Blocksworld domain: Blocksworld problems capture common sense block manipulations and consist of a set of blocks. Blocks are identified with unique colors and are placed either on a table or on top of other blocks. The goal is to arrange some of these blocks in a stack in a particular order. The general expectation here would be that one can pick up a block if it is clear, i.e., there are no other blocks on top of that block and you can only stack a block on top of another block if it is clear. The choice of this particular domain is motivated by both the fact that this is a simple common sense domain and is a very popular domain in planning literature, that has a long history of being used in various planning challenges. The instances were generated using a PDDL generator employed in the IPC competitions. We permitted the generation of problems that varied in terms of the number of blocks (3-5), optimal plan length, and goal properties (positive, negative, or no interactions between subgoals).
+
+As shown in Table 1 and Table 2, GPT-4 improves upon previous versions of GPT models in the Blocksworld domain across all four prompt configurations. However, the overall performance is still approximately $34 \%$ in the Blocksworld dataset. Even the chain of thought style prompting (indicated by COT in the tables) had little effect on improving the performance. GPT-4 performs better with natural language prompts (206 and 210 instances for one-shot and zero-shot prompts, respectively) as opposed to PDDL prompts (75 and 106 instances). The performance drops significantly with other GPT models. We also discovered that for instances where Instruct-GPT3 generated the correct plans, replacing the example plan in the prompt with another example plan led to an even greater drop in accuracy. This suggests that the LLM seems to rely primarily on pattern matching, rather than inducing some internal model from the prompts. Overall, even in a seemingly simple common-sense domain like Blocksworld, which humans typically find easy to navigate, LLMs prove to be quite ineffective in planning autonomously.
+
+Finetuning GPT-3 on Blocksworld: Along with directly testing the LLMs from the GPT family, we have also looked at the utility of fine-tuning the LLMs. Specifically, we fine-tuned GPT-3 (Davinci) in the Blocksworld domain. For this, we prepared a dataset comprising the initial state, goal state, and the respective plan for 1,000 distinct Blocksworld instances. It’s important to note that these instances were separate from our test set of 600 instances. By using the default hyperparameters provided by OpenAI and an 80-20 train-validation data split, we carried out the fine-tuning process. Our results revealed that the fine-tuned GPT-3 solved only 122 instances out of the 600 in our set, representing approximately $20 \%$ of the total. This suggests that fine-tuning has a limited impact on improving the performance of LLMs in Blocksworld planning. This outcome aligns with the observations of [40], who argue that language models trained for reasoning tend to concentrate on the inherent statistical features instead of the causal structure, which in turn affects their performance on such tasks.
+
+Open-source models: In addition to the GPT family of LLMs, we have also conducted preliminary experiments with an open-source LLM, BLOOM [31], and found that BLOOM too is ineffective in plan generation. We assessed BLOOM’s performance in the blocksworld and mystery blocksworld (deceptive) domains using a one-shot natural language prompt configuration. In the blocksworld domain, BLOOM correctly handled only 4 out of 250 instances, representing a $1 . 6 \%$ success rate. In the mystery domain, it failed to produce a single correct response in all 50 instances.
+
+Human Baseline for the Blocksworld: We have previously mentioned that planning tasks on the blocksworld domain are anecdotally simple enough for humans to perform. To establish this and come up with a preliminary baseline to compare LLMs performance, we conducted an IRB-approved user study where we asked 50 participants to come up with a plan for a blocksworld instance picked at random, from the set of 600 instances that we used for the evaluation of LLMs. We presented the same domain description as we did for the LLMs and then primed them with an example instance. We point the reader to the supplementary material for further details on the study.
+
+Out of the 50 participants, 39 of them $(78 \% )$ came up with a valid plan. Along with validity, we also tested the optimality of their plans even though they were not required to come up with an optimal plan. Out of the 39 participants, 35 $( 8 9 . 7 \% )$ participants came up with an optimal plan. These initial results show that the blocksworld domain is a simple enough domain where most humans are able to come up with plans (which are also optimal) while LLMs, on the other hand, showcase subpar performance.
+
+Evaluation of LLMs on the Logistics domain: Logistics is also a widely recognized domain in the planning literature. In this domain, the objective is to transport packages within cities via trucks, and between cities via airplanes. Within a city, the locations are directly linked, allowing trucks to travel between any two of these locations. Similarly, cities are directly connected to each other allowing airplanes to travel between any two cities. Each city is equipped with one truck and has a designated location that functions as an airport. We generated 200 instances on this domain.
+
+From Tables 1 and 2, we see that in the one-shot setting with natural language input, GPT-4 only solved $14 \%$ of the instances (28/200), and this rate dropped to $7 . 5 \%$ (15/200) when using zero-shot prompting. When provided with the domain and problem in PDDL format, GPT-4’s performance remained the same in the one-shot setting $14 \%$ or 28/200) but decreased to $5 . 5 \%$ (11/200) in the zero-shot setting. GPT-3.5 did even worse.
+
+Obfuscating names to test the brittleness of LLM Planning: Although the domain specification is part of our prompts, the names of the objects (e.g. blocks, trucks), predicates (e.g. on-table, in-city) and actions (e.g. pickup, drive) still do provide connections to the commonsense knowledge that the pretrained LLMs possess. One intriguing question is whether the planning performance is based really only on the domain model or these other background connections. To test this, we experimented with a variation of the Blocksworld domain, where we obfuscate the action names (for example pickup becomes attack, and unstack becomes feast) and predicate names (for example ontable becomes planet, and handempty becomes harmony). Note that from the perspective of standard planners, these domains are essentially identical.3 In addition to such deceptive obfuscation, we also considered a variation where random alphanumeric names were substituted for the action and object names.
+
+Tables 1 and 2, we see that this simple obfuscation leads to a catastrophic drop in performance. Specifically, with zero-shot prompting and natural language input, GPT-4 is able to solve 210 instances out of 600 in the Blocksworld domain, but it could only solve 1 instance in the deceptive Mystery Blocksworld domain and 0 instances in the randomized mystery domain. A similar result is observed with the PDDL-style prompts: GPT-4 could solve 106 instances in Blocksworld, but only 3 instances in the deceptive Mystery Blocksworld. Notably, chain of thought prompting does not significantly improve performance over one-shot natural language prompts. GPT-3.5 does not solve even a single instance in the entire set of natural language instances. For most of the instances, GPT-3.5 outputs that the instance can’t be solved. These results strongly suggest that whatever accidental planning performance LLMs show is likely connected to pattern matching rather than reasoning (which should be robust to name change).
+
+![](images/79db4ebc8d5a577b2f247f5c8eef63c89a5f78d19fc05ecd4053e3ee95c61117.jpg)  
+Figure 3: Assessment of GPT-4 plans with relaxations in Blocksworld domain
+
+Table 3: Evaluation of GPT-4 and Instruct-GPT3 (I-GPT-3) plans as heuristics for a local search planner LPG, on blocksworld (BW), logistics and mystery blocksworld domains.   
+
+<table><tr><td rowspan="2">Domain</td><td rowspan="2">LLM</td><td colspan="3">Avg. Search Steps</td><td colspan="3">Avg. Plan Length</td><td rowspan="2">Avg. Lev. Distance</td></tr><tr><td>Empty Seed</td><td>Random Seed</td><td>LLM Seed</td><td>Empty Seed</td><td>Random Seed</td><td>LLM Seed</td></tr><tr><td rowspan="2">BW</td><td>I-GPT-3</td><td>Plan 15.8</td><td>Plan 20.07</td><td>Plan 14.5</td><td>Plan 8.45</td><td>Plan 9.62</td><td>Plan 11.7</td><td>7.22</td></tr><tr><td>GPT-4</td><td>15.8</td><td>20.07</td><td>8.9</td><td>8.45</td><td>9.62</td><td>10.76</td><td>4.15</td></tr><tr><td>Logistics</td><td>GPT-4</td><td>77.5</td><td>144.39</td><td>51.3</td><td>23.7</td><td>32.72</td><td>32.24</td><td>15.04</td></tr><tr><td>Mystery BW</td><td>GPT-4</td><td>15.8</td><td>20.45</td><td>16.09</td><td>8.45</td><td>9.78</td><td>11.53</td><td>7.77</td></tr></table>
+
+Analyzing GPT-4 failures: To get a better sense of the type of failures LLM generated plans encounter, we wondered whether they will fare much better with a more forgiving test of the validity of the generated plans. In automated planning community, the notion of relaxations of the domain model are used to simplify the problem–chiefly to derive heuristics for planning problems [8]. Taking a leaf from them, we considered two types of relaxations: (i) delete relaxation involves ignoring all the delete conditions of the domain actions (thus making sure that there can be no negative interactions between subgoals) and (ii) precondition relaxation involves ignoring all the preconditions of the domain actions–thus assuming that the the actions are executable from any state giving their effects. Our idea is to evaluate the plans produced by GPT4 with respect to domain models that are delete relaxed, precondition relaxed or both. It should be clear that a plan that is correct with respect to the normal (unrelaxed) model will also be correct with respect to all the relaxed models. Figure 3 shows the results for blocksworld. We see that while the correctness of LLM generated plans increased under more forgiving (relaxed) assessments (area in green), even in the most lenient assessment mode (Delete+Precondition Relaxed), there still are plans $( \sim 3 9 \% )$ that are incorrect (because they still don’t reach the goals) across all the prompt configurations. The plots further classify the failure cases in terms of whether they were inexecutable, shown in maroon, or could be executed but didn’t reach the goals (shown in red). Note that when preconditions are relaxed, all plans are executable. We provide additional details on the relaxed assessments in Appendix A.2.
+
+# 5 Evaluating LLMs as Idea Generators
+
+While the preceding discussion establishes that LLMs are not capable of generating correct plans in autonomous mode, there is still the possibility that they can be useful idea generators for other sound external planners, verifiers or even humans-in-the-loop. In this section, we investigate this possibility and demonstrate that LLMs show promise on this front (especially with external planners and verfiers).
+
+# 5.1 LLM Plans as Heuristics to Sound Planners
+
+To see if the LLM generated plans can provide heuristic guidance to sound external planners, we use a local-search planner LPG [6] which generates plans by starting with a seed plan and iteratively repairing flaws until a correct plan is found. We feed the LLM-generated plan as the initial seed plan for LPG’s iterative search. Our hypothesis is that this might put LPG on the right path and reduce the time for it to generate a correct plan. It is interesting to note the similarities between this LLM+LPG approach, and the approaches used in case-based planning in the past [9, 17]. Here the LLM can be loosely viewed as “retrieving a potentially useful plan case/sketch” out of thin air, which the LPG adapts/corrects.
+
+We utilized the plans that were generated by LLMs in the one-shot natural language prompt configuration on all three of our previous domains - Blocksworld, Mystery Blocksworld, and Logistics - as the "seed plans" from which LPG would begin its local search for a valid plan. For the Blocksworld domain, both GPT-4 and Instruct-GPT3 were evaluated, whereas for the Logistics and Mystery domains only GPT-4 was evaluated. We confirmed that all the plans that were generated by this LLM+LPG combination for both the domains were valid (which is as expected given that the underlying planner, LPG, is sound). To get an idea of how far the initial LLM generated plans were from the final correct solutions generated by LPG, we measured the Levenshtein edit distance between them. While the default LPG local search doesn’t aim to minimize the changes to the suggested plan (there do exist versions of LPG that do this; see [23]) , the edit distances also give an idea of how partially or approximately correct the original LLM plan is. Along with the edit distance, we also measured the number of search steps that were taken by the LPG to come up with a correct plan.
+
+As shown in Table 3, the edit distances across domains are approximately half the length of the seed plans generated by the LLMs, indicating that $50 \%$ of the final plan retains the elements of the initial LLM plan. For each problem, we performed two additional plan initializations to serve as baselines: initializing with an empty plan and initializing with a random plan of the same length as the plan generated by the LLM for that problem. In the Blocksworld and Logistics4 domains, we see a significant improvement in search steps over the empty seed plan when GPT-4 is used and an even larger one over the random seed plan. Consistent with our findings in the autonomous mode, the usefulness of this assistance wanes in domains where the relationships between predicates can no longer be inferred from common sense understandings of their names: in the Mystery Blocksworld domain, the LLM only has meager reduction in step size over the random plan and actually uses more steps than the empty plan.
+
+# 5.2 Verifier-assisted repeated backprompting of LLMs
+
+The interaction between LLM and LPG was unidirectional–with LLM sending a seed plan that LPG aims to repair. One supposed advantage of LLMs is that they can be prompted to improve their solutions. Suppose we have access to a sound automated verifier that not only checks the plan correctness but also pinpoints faults (in terms of unsatisfied preconditions or delete interactions). Such feedback can be easily converted into a "backprompt" to the LLM, with the hope that LLM comes up with a better plan. This is what we do with the help of VAL[11]–an AI planning tool that uses the domain model to validate the correctness of the plans (and point out errors).
+
+Table 4: GPT4 Performance with Backprompting by VAL [11]. Mystery BW had deceptive disguising. I.C - Instances correct (within 15 feedbacks); A.F.R - Avg. feedback rounds for correct instances.   
+
+<table><tr><td rowspan="2">Domain</td><td>1.C</td><td>A.FR</td></tr><tr><td>GPT-4</td><td>GPT-4</td></tr><tr><td>Blocksworld (BW)</td><td>41/50 (82%)</td><td>3.68</td></tr><tr><td>Logistics</td><td>35/50 (70%)</td><td>3.31</td></tr><tr><td>Mystery BW</td><td>5/50 (10%)</td><td>7.0</td></tr></table>
+
+While, as we mentioned earlier, there can be thorny “clever hans” issues about humans prompting LLMs, an automated verifier mechanically backprompting the LLM doesn’t suffer from these.
+
+We tested this setup on a subset of the failed instances in the one-shot natural language prompt configuration using GPT-4, given its larger context window. We set a threshold of 15 backprompting rounds. We tested on three domains–Blocksworld, Logistics and Mystery BW–with 50 failed instances from each domain. Table 4 shows the results. We provide the prompt+feedback examples in Appendix A.9. We found that GPT4 is able to come up with correct plans $82 \%$ of the Blocksworld instances and $70 \%$ of the Logistics one. The average number of backprompting rounds for these successful cases was 3.68 for BW and 3.31 for Logistics. The performance on the Mystery BW however remained quite poor–suggesting that even with back prompting, GPT4 cannot do well unless it can tease out commonsense patterns for the domain.
+
+In this backprompting configuration, LLM serves as the candidate plan generator while VAL serves as the external sound verifier. While it is tempting to have a self-critiquing architecture with LLM also serving as the verifier, our recent work shows that approach to be of questionable utility as LLMs are no better at verifying plans than they are at generating them [36, 34].
+
+# 5.3 LLMs as idea generators for humans-in-the-loop
+
+Along with external planners and verifiers, LLMs may also offer their insights as plan suggestions directly to the human-in-the-loop which might potentially guide the user to the correct plan. After all, this sort of computer supported cooperative work (CSCW) use case has been the staple of LLM applications. We explored the efficacy of LLMs in assisting human planners through a betweensubjects user study, structured similarly to the study outlined in Section 4, but with two primary distinctions: (1) The study involved two separate participant groups. The first group received no assistance in devising plans, paralleling the approach in Section 4, while the second group had access to LLM-generated suggestions. (2) both participant sets were asked to offer subjective feedback via the NASA-TLX assessment tool [10], gauging their cognitive load. Additionally, participants from the second group evaluated the correctness of the LLM suggestions presented to them. We utilized the plans generated by GPT-4 to provide plan suggestions.
+
+The study included 49 participants in the unassisted group and 48 in the LLM-assisted group. We evaluated the statistical significance regarding accuracy, time taken, and cognitive load between the groups. Our findings revealed no statistical significance between the groups across all three aspects.5. Notably, 3 out of 48 participants mistakenly accepted incorrect LLM suggestions, with two submitting these erroneous suggestions as their plans. This shows the potential for automation bias in such methodologies [5]. We have provided the details of the user-study in Appendix A.12.
+
+# 6 Conclusion and Future Work
+
+In this paper, we presented a critical investigation of the planning abilities of large language models (LLMs). To this end, we evaluated the plan generation abilities of LLMs in two different modes. In the autonomous mode, our results show that even in simple common-sense planning domains where humans could easily come up with plans, LLMs like GPT-3 exhibit a dismal performance. Even though there is an uptick in the performance by the newer GPT-4 in the blocksworld domain, it still fails miserably on the mystery blocksworld domain, indicating their inability to reason in an abstract manner. In the heuristic mode, we have seen that plans generated by LLMs can help improve the search of sound planners like LPG. Further, we showed that using external verifiers, we can point out the errors and back-prompt LLMs for a better plan. We showed that this indeed helps in common-sense domains. In the supplementary material, we show the prompt examples for all the configurations and the details of the user-studies (Appendix A.11). From our studies, we see that LLMs as autonomous planners fail miserably, but we also see that the generated plans improve the search when used by an underlying sound planner and that better plans can be obtained by back-prompting the LLM with feedback from an external verifier.
+
+# 7 Acknowledgements
+
+This research was supported by ONR grants N00014-18-1-2442, N00014-18-1-2840, N00014- 19-1-2119 and N00014-23-1-2409, AFOSR grant FA9550-18-1-0067, DARPA SAIL-ON grant W911NF-19-2-0006, and a JP Morgan AI Faculty Research Grant to Kambhampati. Sreedharan was supported in part by NSF grant 2303019.
+
+# References
+
+[1] Clever Hans. https://en.wikipedia.org/wiki/Clever_Hans.
+
+[2] Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Keerthana Gopalakrishnan, Karol Hausman, Alex Herzog, et al. Do as i can, not as i say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.01691, 2022.
+
+[3] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020.
+
+[4] Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm: Scaling language modeling with pathways. arXiv preprint arXiv:2204.02311, 2022.
+
+[5] Mary L Cummings. Automation bias in intelligent time critical decision support systems. In Decision making in aviation, pages 289–294. Routledge, 2017.
+
+[6] Alfonso Gerevini and Ivan Serina. Lpg: A planner based on local search for planning graphs with action costs. In AIPS, volume 2, pages 281–290, 2002.
+
+[7] Mor Geva, Daniel Khashabi, Elad Segal, Tushar Khot, Dan Roth, and Jonathan Berant. Did aristotle use a laptop? a question answering benchmark with implicit reasoning strategies. Transactions of the Association for Computational Linguistics, 9:346–361, 2021.
+
+[8] Malik Ghallab, Dana S. Nau, and Paolo Traverso. Automated Planning and Acting. Cambridge University Press, 2016.
+
+[9] Kristian J. Hammond. CHEF: A model of case-based planning. In Tom Kehler, editor, Proceedings of the 5th National Conference on Artificial Intelligence. Philadelphia, PA, USA, August 11-15, 1986. Volume 1: Science, pages 267–271. Morgan Kaufmann, 1986.
+
+[10] Sandra G Hart and Lowell E Staveland. Development of nasa-tlx (task load index): Results of empirical and theoretical research. Advances in psychology, 52:139–183, 1988.
+
+[11] Richard Howey, Derek Long, and Maria Fox. VAL: Automatic plan validation, continuous effects and mixed initiative planning using PDDL. In 16th IEEE International Conference on Tools with Artificial Intelligence, pages 294–301. IEEE, 2004.
+
+[12] Wenlong Huang, Pieter Abbeel, Deepak Pathak, and Igor Mordatch. Language models as zero-shot planners: Extracting actionable knowledge for embodied agents. In International Conference on Machine Learning, pages 9118–9147. PMLR, 2022.
+
+[13] Wenlong Huang, Fei Xia, Ted Xiao, Harris Chan, Jacky Liang, Pete Florence, Andy Zeng, Jonathan Tompson, Igor Mordatch, Yevgen Chebotar, et al. Inner monologue: Embodied reasoning through planning with language models. arXiv preprint arXiv:2207.05608, 2022.
+
+[14] IPC. International planning competition, 1998.
+
+[15] Liwei Jiang, Jena D. Hwang, Chandrasekhar Bhagavatula, Ronan Le Bras, Maxwell Forbes, Jon Borchardt, Jenny Liang, Oren Etzioni, Maarten Sap, and Yejin Choi. Delphi: Towards Machine Ethics and Norms. ArXiv, abs/2110.07574, 2021.
+
+[16] Subbarao Kambhampati. AI as (an Ersatz) Natural Science? https://cacm.acm.org/blogs/blogcacm/261732-ai-as-an-ersatz-natural-science/fulltext, Jun 2022.
+
+[17] Subbarao Kambhampati and James A. Hendler. A validation-structure-based theory of plan modification and reuse. Artif. Intell., 55(2):193–258, 1992.
+
+[18] Subbarao Kambhampati, Karthik Valmeekam, Matthew Marquez, and Lin Guan. On the role of large language models in planning, July 2023. Tutorial presented at the International Conference on Automated Planning and Scheduling (ICAPS), Prague. https://yochan-lab.github. io/tutorial/ICAPS-2023/.
+
+[19] Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. Large Language Models are Zero-Shot Reasoners. arXiv preprint arXiv:2205.11916, 2022.
+
+[20] Paul Pu Liang, Chiyu Wu, Louis-Philippe Morency, and Ruslan Salakhutdinov. Towards understanding and mitigating social biases in language models. In International Conference on Machine Learning, pages 6565–6576. PMLR, 2021.
+
+[21] Bo Liu, Yuqian Jiang, Xiaohan Zhang, Qiang Liu, Shiqi Zhang, Joydeep Biswas, and Peter Stone. Llm+ p: Empowering large language models with optimal planning proficiency. arXiv preprint arXiv:2304.11477, 2023.
+
+[22] Drew McDermott, Malik Ghallab, Adele E. Howe, Craig A. Knoblock, Ashwin Ram, Manuela M. Veloso, Daniel S. Weld, and David E. Wilkins. Pddl-the planning domain definition language. 1998.
+
+[23] Tuan Anh Nguyen, Minh Do, Alfonso Emilio Gerevini, Ivan Serina, Biplav Srivastava, and Subbarao Kambhampati. Generating diverse plans to handle unknown and partially known user preferences. Artificial Intelligence, 190:1–31, 2012.
+
+[24] OpenAI. Introducing chatgpt by openai, 2022.
+
+[25] OpenAI. Gpt-4 technical report, 2023.
+
+[26] Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. arXiv preprint arXiv:2203.02155, 2022.
+
+[27] Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. 2018.
+
+[28] Shreyas Sundara Raman, Vanya Cohen, Eric Rosen, Ifrah Idrees, David Paulius, and Stefanie Tellex. Planning with large language models via corrective re-prompting. arXiv preprint arXiv:2211.09935, 2022.
+
+[29] Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An adversarial winograd schema challenge at scale. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 8732–8740, 2020.
+
+[30] Patrick Schramowski, Cigdem Turan, Nico Andersen, Constantin A Rothkopf, and Kristian Kersting. Large pre-trained language models contain human-like biases of what is right and wrong to do. Nature Machine Intelligence, 4(3):258–268, 2022.
+
+[31] Big Science. BigScience Large Open-science Open-access Multilingual Language Model. https://huggingface.co/bigscience/bloom, 2022.
+
+[32] Tom Silver, Varun Hariprasad, Reece S Shuttleworth, Nishanth Kumar, Tomás Lozano-Pérez, and Leslie Pack Kaelbling. PDDL planning with pretrained large language models. In NeurIPS 2022 Foundation Models for Decision Making Workshop, 2022.
+
+[33] Aarohi Srivastava, Abhinav Rastogi, Abhishek Rao, Abu Awal Md Shoeb, Abubakar Abid, Adam Fisch, Adam R Brown, Adam Santoro, Aditya Gupta, Adrià Garriga-Alonso, et al. Beyond the imitation game: Quantifying and extrapolating the capabilities of language models. arXiv preprint arXiv:2206.04615, 2022.
+
+[34] Kaya Stechly, Matthew Marquez, and Subbarao Kambhampati. Gpt-4 doesn’t know it’s wrong: An analysis of iterative prompting for reasoning problems. arXiv preprint arXiv:2310.12397, 2023.
+
+[35] Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. Commonsenseqa: A question answering challenge targeting commonsense knowledge. arXiv preprint arXiv:1811.00937, 2018.
+
+[36] Karthik Valmeekam, Matthew Marquez, and Subbarao Kambhampati. Can large language models really improve by self-critiquing their own plans? arXiv preprint arXiv:2310.08118, 2023.
+
+[37] Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Ed Chi, Quoc Le, and Denny Zhou. Chain of thought prompting elicits reasoning in large language models. arXiv preprint arXiv:2201.11903, 2022.   
+[38] Yaqi Xie, Chen Yu, Tongyao Zhu, Jinbin Bai, Ze Gong, and Harold Soh. Translating natural language to planning goals with large-language models. arXiv preprint arXiv:2302.05128, 2023.   
+[39] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations, 2023.   
+[40] Honghua Zhang, Liunian Harold Li, Tao Meng, Kai-Wei Chang, and Guy Van den Broeck. On the paradox of learning to reason from data. arXiv preprint arXiv:2205.11502, 2022.

parse/dev/X6dEqXIsEW/X6dEqXIsEW_content_list.json

@@ -0,0 +1,1248 @@
+[
+    {
+        "type": "text",
+        "text": "On the Planning Abilities of Large Language Models : A Critical Investigation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            122,
+            826,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Karthik Valmeekam School of Computing & AI Arizona State University Tempe. kvalmeek@asu.edu ",
+        "bbox": [
+            243,
+            226,
+            459,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Matthew Marquez School of Computing & AI Arizona State University, Tempe. mmarqu22@asu.edu ",
+        "bbox": [
+            535,
+            227,
+            753,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sarath Sreedharan∗ Department of Computer Science, Colorado State University, Fort Collins. sarath.sreedharan@colostate.edu ",
+        "bbox": [
+            228,
+            303,
+            493,
+            357
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Subbarao Kambhampati School of Computing & AI Arizona State University, Tempe. rao@asu.edu ",
+        "bbox": [
+            552,
+            303,
+            771,
+            358
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            395,
+            535,
+            411
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Intrigued by the claims of emergent reasoning capabilities in LLMs trained on general web corpora, in this paper, we set out to investigate their planning capabilities. We aim to evaluate (1) the effectiveness of LLMs in generating plans autonomously in commonsense planning tasks and (2) the potential of LLMs as a source of heuristic guidance for other agents (AI planners) in their planning tasks. We conduct a systematic study by generating a suite of instances on domains similar to the ones employed in the International Planning Competition and evaluate LLMs in two distinct modes: autonomous and heuristic. Our findings reveal that LLMs’ ability to generate executable plans autonomously is rather limited, with the best model (GPT-4) having an average success rate of ${ \\sim } 1 2 \\%$ across the domains. However, the results in the heuristic mode show more promise. In the heuristic mode, we demonstrate that LLM-generated plans can improve the search process for underlying sound planners and additionally show that external verifiers can help provide feedback on the generated plans and back-prompt the LLM for better plan generation. ",
+        "bbox": [
+            233,
+            426,
+            766,
+            635
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            310,
+            679
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It would be no exaggeration to say that transformer-based large language models (LLMs) have revolutionized the field of natural language processing (NLP). Kicked off by the advances presented by the GPT- $\\mathbf { X }$ models developed by OpenAI [27], these types of language models currently provide state-of-the-art performance in many of the standard NLP tasks. Although LLMs were originally developed mostly to do word sequence completion tasks, with no guarantees about the completion beyond its coherence, there have been increasing claims and anecdotal evidence that they have other emergent capabilities that are not normally associated with sequence completion. Indeed, the hints of such emergent capabilities has started a veritable land rush, with researchers probing (prompting) and studying LLM behavior almost as if they were artificial organisms (c.f. [16]). Of particular interest to us in this paper is the thread of efforts that aim to investigate (and showcase) reasoning abilities of LLMs–including commonsense reasoning [35, 29, 7], logical reasoning [33], and even ethical reasoning [15]. The macro-tenor of the drumbeat of these works has been suggesting that LLM’s are indeed capable of doing such kinds of reasoning [19, 37, 4]. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One type of reasoning task that has been well studied in the AI community is planning and sequential decision making. At its simplest, planning involves developing a course of actions (policy) which when executed takes the agent to a desired state of the world. Planning has generally been studied primarily as an inference on world and reward models–whether specified by humans or learned by the agent by interacting with its world. In this paper, we are interested in seeing what planning abilities, if any, LLMs may already have, given their high capacity functions (with billions of tunable parameters) trained on web-scale corpora. Specifically, we are interested in answering two broad questions: ",
+        "bbox": [
+            173,
+            90,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. How effective are LLMs by themselves in generating simple plans in commonsense planning tasks (of the type that humans are generally quite good at)?   \n2. How good are LLMs in being a source of heuristic guidance for other agents in their planning tasks? ",
+        "bbox": [
+            209,
+            200,
+            825,
+            262
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notice that in theory, it is possible for LLMs to be very effective as idea generators for external sound planners or humans in the loop in computer-supported cooperative work scenarios, while themselves being very bad at generating plans that are guaranteed to be correct. This is especially likely because the chief power of LLMs comes from their pattern-finding abilities than from firstprinciples simulations over world models. Compared to a planner that is guaranteed to be correct in a narrow set of domains, LLMs may likely be good at generating plausible (but not guaranteed to be correct) plan heuristics/suggestions in many more domains. ",
+        "bbox": [
+            174,
+            273,
+            825,
+            372
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To investigate these questions in a systematic rather than anecdotal manner, we generate a suite of planning problem instances 2 based on the kinds of domains employed in the International Planning Competition [14]. To eliminate the subjective aspect of analysis that forms the core part of many earlier efforts on evaluating the reasoning capabilities of LLMs, we automate the evaluation by leveraging models and tools from the automated planning community. The evaluation itself is done in two modes (shown in Figure 1). In the first “autonomous\" mode, LLMs are used standalone, and we directly assess the quality and correctness of plans they generate. As we shall see, the results in the autonomous mode are pretty bleak. On an average, only about $12 \\%$ of the plans that the best LLM (GPT-4) generates are actually executable without errors and reach their goals. We will show that the choice of the specific LLM (we have tested the family of GPT LLMs including GPT-4 [25], GPT-3.5 [24], InstructGPT-3.5, InstructGPT-3 [26] and GPT-3 [3]), as well as fine tuning does not seem to have a major effect on this dismal performance. We also show that the performance deteriorates further if the names of the actions and objects in the domain are obfuscated–a change that doesn’t in anyway affect the performance of the standard AI planners. To shed further light on the performance of GPT4, we present an evaluation of the plans it generates under a series of more relaxed (more forgiving) executability conditions. Further, we provide a human baseline for the simplest domain in our set of domains, by presenting the planning instances to human subjects (through IRB-approved studies) and evaluating the quality and correctness of their plans. These results are substantially better than those of LLMs–confirming that LLMs can’t plan even in a simple common sense domain in the autonomous mode. In the second “heuristic\" mode, the plans produced by LLMs are given as input to an automated planner working off of a correct domain model to check whether the LLM’s plans help with the search process of the underlying planner to come up with correct plans. Specifically we show that a well known automated planner called LPG [6], that uses local search to locate and remove flaws in a candidate plan to make it correct, is able to repair the LLM plans with relative ease. We compare the LLM+LPG combination with two baselines, one where an empty plan is used as the seed plan for the LPG and two, where a random plan is provided as the seed plan to the LPG. We show that the average search steps by the LLM+LPG combination is much lesser than both the baselines, thereby revealing that LLMs’ plans are indeed helping with the search process of the underlying planner. Further, instead of having LPG correct the plans, we use an external verifier, VAL [11], to point out the errors in the LLM-generated plans and back-prompt the LLM for a new plan with this feedback. We show that this repeated interaction indeed improves the plan correctness in common-sense domains. Overall, our findings demonstrate that, with respect to planning, LLMs’ perform poorly in the autonomous mode but the generated plans can help AI planners in the search process or can be given to external verifiers and back-prompt the LLM for better plans. In this paper, we first present an overview of the related work. Following that, we describe the necessary background and the prompt generation pipeline. Finally, we provide the results and analysis of various experiments undertaken in both autonomous and heuristic evaluation modes. ",
+        "bbox": [
+            174,
+            378,
+            825,
+            448
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/89c4ff73d93d4e9706caa68cf963311cc1fc37c13740df2131635c53ad85a188.jpg",
+        "image_caption": [
+            "Figure 1: The diagrammatic overview of the two modes of LLMs for planning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            251,
+            462,
+            754,
+            609
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            637,
+            825,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            299,
+            321,
+            316
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we look at LLMs’ planning capabilities when the domain is given as part of the prompt (as is the standard practice in automated planning [8]). Our evaluation focuses on zero-shot (just domain and problem specification), and few-shot (example problems with plans) modes. There have been a few works that looked at the planning capabilities of LLMs. Most of them, such as [12, 2] focus on commonsense domains/tasks (e.g. moving things in kitchens, wedding/menu planning etc.) and thus evaluate LLMs in a mode wherein the prompt doesn’t include any information about the specific domain. Plans generated in that way are hard to evaluate as they are not directed at any plan executor and the humans often wind up giving the benefit of doubt for a plausible–but not actually executable–plan. This is why in SayCan [2], where executability is critical, they try to filter out/interpret the LLM plans in terms of the skills/actions that are actually available to the executor. While SayCan does this in a rather convoluted way that requires access to the internal log probabilities of the LLM, our approach simplifies this by specifying the domain as part of the prompt. In all our experiments, we found that LLMs only use the actions listed as part of the domain specification. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One other mode of evaluation of planning capabilities in the literature involves the user incrementally interacting with the LLM, and re-prompting it to point out flaws in its plans, with the hope that the LLM eventually reaches an executable plan [13, 39, 28]. Such evaluations are notorious for their Clever Hans effect [1] with the actual planning being done by the humans in the loop rather than the LLMs themselves. We thus separate our evaluation into two modes–autonomous and as assistants to external planners/reasoners. There have also been efforts which mostly depended on LLMs as “translators\" of natural language problem/goal specification into formal specifications, which are then thrown over to sound external planners [38, 21]. Such efforts don’t shed any light on the internal planning capabilities of the LLMs themselves, as our evaluations in autonomous and assistive modes do. Finally, after our initial study and benchmark were made public, other groups did parallel studies that largely corroborate our results on the ineffectiveness of LLMs in finding executable plans [32, 21]. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Taking a broader perspective, making plans in the world involves (1) discovering actions (and their precondition/effect causal dependencies), and (2) sequencing an appropriate subset of available/discovered actions to achieve the agent’s goals. The former requires broad knowledge about actions available in the world and their individual effects, while the latter requires deep drilling-down over a given set of actions to ensure that all goals are supported (causal chaining) without any undesirable interactions. LLMs have an edge on the former–they do indeed have web-scale broad knowledge! As we shall see however, they are very bad at the second phase of developing valid interaction-free plans (in part, because LLMs don’t have the ability to do combinatorial search). Most cases in literature (as outlined in [18]) where LLMs are claimed to have \"planned\" turn out, upon close examination, to be instances of phase 1–your wedding plans, recipe plans etc.–where you are either using a very forgiving plan correctness criterion, or the phase 2 is vacuous. Standard AI planners–on the other hand–assume that the discovery part is done and handed down as a compact domain model, and focus mostly on the second part: selecting among known actions to establish causal chains and sequencing them to make them interaction free. In this sense, LLMs and AI planners can be complementary, as we have shown in this paper–with the former helping with phase 1–either with a candidate/approximate plan or domain model–and the latter with phase 2. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Prompt Generation for Classical Planning Problems ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            640,
+            107
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            121,
+            299,
+            136
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given that we are interested in investigating the basic reasoning about actions and change problem, we want to look at the most fundamental planning formalism first, namely the goal-directed deterministic planning problem. Colloquially referred to as classical planning problem, these problem classes consist of a problem domain, an initial state and a goal state. The problem domain consists of a set of fluents which correspond to predicates with some arity and a set of actions. The state-space for the planning problem is defined by the possible truth assignment over the predicates. Each action consists of preconditions and effects where preconditions is a set of predicates that describe when an action can be executed and effects are set of predicates that describe what happens when an action is executed. The effects can further consist of add effects, which is the set of predicates that will be set true by the action, and delete effects, which is the set of predicates that will be set false. The solution for a planning problem is a sequence of actions, or a plan, that when applied in the initial state will result in a state where the goal conditions are satisfied. A standard representation to specify such kind of planning problems is the Planning Definition and Domain Language (PDDL) [22]. Below is a snippet of an action from a popular benchmark problem called Blocksworld, in PDDL. The action corresponds to picking up a block in that domain. ",
+        "bbox": [
+            174,
+            146,
+            825,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(:action pickup :parameters (?ob) :precondition (and (clear ?ob) (on-table ?ob) (arm-empty)) :effect (and (holding ?ob) (not (clear ?ob)) (not (on-table ?ob)) (not (arm-empty)))) ",
+        "bbox": [
+            199,
+            380,
+            604,
+            433
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A more detailed description on classical planning problems is provided in Appendix A.1. We now will describe how we generate the prompts that are given to the LLMs. ",
+        "bbox": [
+            174,
+            463,
+            823,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Prompt Generation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            510,
+            349,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/642747863f0ac95f99387bb3732e05cc831ea3428dac9efab84f28bb5198f230.jpg",
+        "image_caption": [
+            "Figure 2: The diagrammatic overview of the prompt generation pipeline. The prompt configurations for the different experiments are generated from PDDL domain files and are modified with an example generator and natural language translator as needed depending on the experiment requirements. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            545,
+            761,
+            671
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Prompt Configurations: We have developed a suite of unique planning problems to test LLMs’ abilities to generate plans. We have multiple prompt configurations based on this suite of problems, varying in both the method of presentation as well as number of examples given to the LLM. In particular, we use two methods of presentation, natural language and PDDL, as well as two different methods of providing examples, zero shot (with no examples provided) and one shot (with an example provided), giving us four different configuration combinations for our experiments. ",
+        "bbox": [
+            173,
+            738,
+            825,
+            821
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Within a prompt, LLMs are first provided with a lifted domain description. For one shot configurations, the prompt additionally contains an example instance of a planning problem (consisting of a description of the initial state and the goal) and the corresponding plan (which ends with a tag, referred to as the plan-end tag, that denotes the end of the plan). All prompts end with a planning problem description. The text generated by the LLM until the plan-end tag is used as the candidate for extracting the plan. If the extractor cannot reasonably extract an instance, it is marked as incorrect. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/227e2c1fa88c5e6a4477527b30589b83688e8cff3dc2f8e57c439fe69d38ebfc.jpg",
+        "table_caption": [
+            "Table 1: Results of GPT-4, GPT-3.5 (popularly known as ChatGPT), Instruct-GPT3.5, Instruct-GPT3 (text-davinci-002) and GPT3 (davinci) for the Plan Generation task with prompts in natural language. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Domain</td><td rowspan=\"2\">Method</td><td colspan=\"5\">Instances correct</td></tr><tr><td>GPT-4</td><td>GPT-3.5</td><td>I-GPT3.5</td><td>I-GPT3</td><td>GPT-3</td></tr><tr><td rowspan=\"3\">Blocksworld (BW)</td><td>One-shot</td><td>206/600 (34.3%)</td><td>37/600 (6.1%)</td><td>54/600 (9%)</td><td>41/600 (6.8%)</td><td>6/600 (1%)</td></tr><tr><td>Zero-shot</td><td>210/600 (34.6%)</td><td>8/600 (1.3%)</td><td>1</td><td>1</td><td>1</td></tr><tr><td>COT</td><td>214/600 (35.6%)</td><td>=</td><td></td><td>1</td><td></td></tr><tr><td rowspan=\"2\">Logistics Domain</td><td>One-shot</td><td>28/200 (14%)</td><td>1/200 (0.5%)</td><td>6/200 (3%)</td><td>3/200 (1.5%)</td><td></td></tr><tr><td>Zero-shot</td><td>15/200 (7.5%)</td><td>1/200 (0.5%)</td><td>=</td><td>-</td><td>1</td></tr><tr><td rowspan=\"3\">Mystery BW (Deceptive)</td><td>One-shot</td><td>26/600 (4.3%)</td><td>0/600 (0%)</td><td>4/600 (0.6%)</td><td>14/600</td><td>0/600</td></tr><tr><td>Zero-shot</td><td>1/600 (0.16%)</td><td>0/600 (0%)</td><td>-</td><td>(2.3%) 1</td><td>(0%) 1</td></tr><tr><td>COT</td><td>54/600 (9%)</td><td></td><td>-</td><td>-</td><td>1</td></tr><tr><td rowspan=\"2\">Mystery BW (Randomized)</td><td>One-shot</td><td>12/600 (2%)</td><td>0/600 (0%)</td><td>5/600 (0.8%)</td><td>5/600 (0.8%)</td><td>1/600</td></tr><tr><td>Zero-shot</td><td>0/600 (0%)</td><td>0/600 (0%)</td><td>-</td><td>-</td><td>(0.1%) -</td></tr></table>",
+        "bbox": [
+            174,
+            121,
+            820,
+            405
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The prompt is either formatted in natural langauge or PDDL. Natural language prompts utilize complete natural language sentences to describe feasible actions in the domain. Initial conditions are also reported as complete sentences. Plans in the natural language setting take the form of a series of commands such as \"stack the orange block on top of the blue block\". As implied by the name, PDDL prompts format all elements (domain description, initial state, goal state, and plans) using PDDL. We point the reader to the supplementary material for examples on each of these prompt configurations. ",
+        "bbox": [
+            173,
+            420,
+            825,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Chain of Thought Prompting: In addition to the four experiments above, we look at a fifth experiment using a state tracking chain of thought prompting technique in a natural language one shot setting. Within this configuration, we provide an annotated example where each action is annotated with the state prior to the action, the reason for why the action is applicable in the prior state, and the resulting state after applying the action. After the example, a meta-explanation about plan correctness is provided. The LLM is then asked to return a response making the same state tracking and justification annotations that were included in the example. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            613
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Prompt Generation Pipeline: We’ve developed a prompt generation pipeline (visualized in Figure 2) that accepts PDDL domain files as input and outputs prompts that follow the experiments described above. The prompt generation component takes care of creating the set of PDDL problems to be solved for all experiments. Following that, examples are added to the prompt in one shot experiments. While our setup utilizes a planner during example generation, any example generation technique could be used here so long as the examples generated are valid plans. In the state tracking experiment, we also have developed a component to add justification annotations for examples so that the examples reflect what we expect of the LLM. The last step before finishing is translation: since problems at this point are currently in PDDL, prompts for all natural language experiments (whether an example was added or not) need to be translated into natural language. We utilize a domain-specific translator to do so. ",
+        "bbox": [
+            173,
+            626,
+            825,
+            779
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Evaluating Planning Capabilities of LLMs in Autonomous Mode ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            741,
+            814
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the autonomous mode, we treat the LLM as an automated planner and perform a single run of the dataset on the LLMs for each domain and prompt configuration. In this mode, the plan generated by the LLM is back-translated from natural language to forms that can be used by external plan validators. For each domain, we perform template-based translation to translate between PDDL and natural language for the natural language prompt configurations. We use VAL [11] to evaluate the translated plan with the corresponding domain and problem file. Our evaluation here primarily focuses on the GPT family of LLMs. We tested GPT-4 [25] and GPT-3.5 (commonly known as Chat-GPT) [24] on all the prompt configurations while we tested the older versions of GPT (namely, Instruct-GPT3 and GPT3) on one-shot natural language prompts across the domains. We set the temperature for all models to be 0, thereby making them deterministic. In this section, we detail the evaluation of LLMs on these domains and prompt configurations. We would like to point the reader to the Appendix for example prompts. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/c8a2d7201517b6ce6ff9efc88d8f6d4ddfafd19773aad3dca427ec8bfddfdd71.jpg",
+        "table_caption": [
+            "Table 2: Results of GPT-4 and GPT-3.5 (popularly known as ChatGPT) for the Plan Generation task with one or zero examples in the prompt by directly providing the domain and problem in PDDL. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Domain</td><td rowspan=\"2\">Method</td><td colspan=\"2\">Instances correct</td></tr><tr><td>GPT-4</td><td>GPT-3.5</td></tr><tr><td rowspan=\"2\">Blocksworld (BW)</td><td>One-shot</td><td>75/600 (12.5%)</td><td>12/600 (2%)</td></tr><tr><td>Zero-shot</td><td>106/600 (17.6%)</td><td>12/600 (2%)</td></tr><tr><td rowspan=\"2\">Logistics Domain</td><td>One-shot</td><td>28/200 (14%)</td><td>1/200 (0.5%)</td></tr><tr><td>Zero-shot</td><td>11/200 (5.5%)</td><td>0/200 (0%)</td></tr><tr><td rowspan=\"2\">Mystery BW (Deceptive)</td><td>One-shot</td><td>17/600 (2.8%)</td><td>1/600 (0.1%)</td></tr><tr><td>Zero-shot</td><td>3/600 (0.5%)</td><td>0/600 (0%)</td></tr></table>",
+        "bbox": [
+            261,
+            122,
+            732,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            304,
+            825,
+            388
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation of LLMs on the Blocksworld domain: Blocksworld problems capture common sense block manipulations and consist of a set of blocks. Blocks are identified with unique colors and are placed either on a table or on top of other blocks. The goal is to arrange some of these blocks in a stack in a particular order. The general expectation here would be that one can pick up a block if it is clear, i.e., there are no other blocks on top of that block and you can only stack a block on top of another block if it is clear. The choice of this particular domain is motivated by both the fact that this is a simple common sense domain and is a very popular domain in planning literature, that has a long history of being used in various planning challenges. The instances were generated using a PDDL generator employed in the IPC competitions. We permitted the generation of problems that varied in terms of the number of blocks (3-5), optimal plan length, and goal properties (positive, negative, or no interactions between subgoals). ",
+        "bbox": [
+            174,
+            411,
+            825,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1 and Table 2, GPT-4 improves upon previous versions of GPT models in the Blocksworld domain across all four prompt configurations. However, the overall performance is still approximately $34 \\%$ in the Blocksworld dataset. Even the chain of thought style prompting (indicated by COT in the tables) had little effect on improving the performance. GPT-4 performs better with natural language prompts (206 and 210 instances for one-shot and zero-shot prompts, respectively) as opposed to PDDL prompts (75 and 106 instances). The performance drops significantly with other GPT models. We also discovered that for instances where Instruct-GPT3 generated the correct plans, replacing the example plan in the prompt with another example plan led to an even greater drop in accuracy. This suggests that the LLM seems to rely primarily on pattern matching, rather than inducing some internal model from the prompts. Overall, even in a seemingly simple common-sense domain like Blocksworld, which humans typically find easy to navigate, LLMs prove to be quite ineffective in planning autonomously. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finetuning GPT-3 on Blocksworld: Along with directly testing the LLMs from the GPT family, we have also looked at the utility of fine-tuning the LLMs. Specifically, we fine-tuned GPT-3 (Davinci) in the Blocksworld domain. For this, we prepared a dataset comprising the initial state, goal state, and the respective plan for 1,000 distinct Blocksworld instances. It’s important to note that these instances were separate from our test set of 600 instances. By using the default hyperparameters provided by OpenAI and an 80-20 train-validation data split, we carried out the fine-tuning process. Our results revealed that the fine-tuned GPT-3 solved only 122 instances out of the 600 in our set, representing approximately $20 \\%$ of the total. This suggests that fine-tuning has a limited impact on improving the performance of LLMs in Blocksworld planning. This outcome aligns with the observations of [40], who argue that language models trained for reasoning tend to concentrate on the inherent statistical features instead of the causal structure, which in turn affects their performance on such tasks. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Open-source models: In addition to the GPT family of LLMs, we have also conducted preliminary experiments with an open-source LLM, BLOOM [31], and found that BLOOM too is ineffective in plan generation. We assessed BLOOM’s performance in the blocksworld and mystery blocksworld (deceptive) domains using a one-shot natural language prompt configuration. In the blocksworld domain, BLOOM correctly handled only 4 out of 250 instances, representing a $1 . 6 \\%$ success rate. In the mystery domain, it failed to produce a single correct response in all 50 instances. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Human Baseline for the Blocksworld: We have previously mentioned that planning tasks on the blocksworld domain are anecdotally simple enough for humans to perform. To establish this and come up with a preliminary baseline to compare LLMs performance, we conducted an IRB-approved user study where we asked 50 participants to come up with a plan for a blocksworld instance picked at random, from the set of 600 instances that we used for the evaluation of LLMs. We presented the same domain description as we did for the LLMs and then primed them with an example instance. We point the reader to the supplementary material for further details on the study. ",
+        "bbox": [
+            174,
+            191,
+            825,
+            289
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Out of the 50 participants, 39 of them $(78 \\% )$ came up with a valid plan. Along with validity, we also tested the optimality of their plans even though they were not required to come up with an optimal plan. Out of the 39 participants, 35 $( 8 9 . 7 \\% )$ participants came up with an optimal plan. These initial results show that the blocksworld domain is a simple enough domain where most humans are able to come up with plans (which are also optimal) while LLMs, on the other hand, showcase subpar performance. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            377
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation of LLMs on the Logistics domain: Logistics is also a widely recognized domain in the planning literature. In this domain, the objective is to transport packages within cities via trucks, and between cities via airplanes. Within a city, the locations are directly linked, allowing trucks to travel between any two of these locations. Similarly, cities are directly connected to each other allowing airplanes to travel between any two cities. Each city is equipped with one truck and has a designated location that functions as an airport. We generated 200 instances on this domain. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "From Tables 1 and 2, we see that in the one-shot setting with natural language input, GPT-4 only solved $14 \\%$ of the instances (28/200), and this rate dropped to $7 . 5 \\%$ (15/200) when using zero-shot prompting. When provided with the domain and problem in PDDL format, GPT-4’s performance remained the same in the one-shot setting $14 \\%$ or 28/200) but decreased to $5 . 5 \\%$ (11/200) in the zero-shot setting. GPT-3.5 did even worse. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Obfuscating names to test the brittleness of LLM Planning: Although the domain specification is part of our prompts, the names of the objects (e.g. blocks, trucks), predicates (e.g. on-table, in-city) and actions (e.g. pickup, drive) still do provide connections to the commonsense knowledge that the pretrained LLMs possess. One intriguing question is whether the planning performance is based really only on the domain model or these other background connections. To test this, we experimented with a variation of the Blocksworld domain, where we obfuscate the action names (for example pickup becomes attack, and unstack becomes feast) and predicate names (for example ontable becomes planet, and handempty becomes harmony). Note that from the perspective of standard planners, these domains are essentially identical.3 In addition to such deceptive obfuscation, we also considered a variation where random alphanumeric names were substituted for the action and object names. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Tables 1 and 2, we see that this simple obfuscation leads to a catastrophic drop in performance. Specifically, with zero-shot prompting and natural language input, GPT-4 is able to solve 210 instances out of 600 in the Blocksworld domain, but it could only solve 1 instance in the deceptive Mystery Blocksworld domain and 0 instances in the randomized mystery domain. A similar result is observed with the PDDL-style prompts: GPT-4 could solve 106 instances in Blocksworld, but only 3 instances in the deceptive Mystery Blocksworld. Notably, chain of thought prompting does not significantly improve performance over one-shot natural language prompts. GPT-3.5 does not solve even a single instance in the entire set of natural language instances. For most of the instances, GPT-3.5 outputs that the instance can’t be solved. These results strongly suggest that whatever accidental planning performance LLMs show is likely connected to pattern matching rather than reasoning (which should be robust to name change). ",
+        "bbox": [
+            174,
+            715,
+            825,
+            867
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/79db4ebc8d5a577b2f247f5c8eef63c89a5f78d19fc05ecd4053e3ee95c61117.jpg",
+        "image_caption": [
+            "Figure 3: Assessment of GPT-4 plans with relaxations in Blocksworld domain "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            92,
+            823,
+            237
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f657318603c39f9a9b9d025cbfc5e3b3bca332ed845c255093db5f86ada17f34.jpg",
+        "table_caption": [
+            "Table 3: Evaluation of GPT-4 and Instruct-GPT3 (I-GPT-3) plans as heuristics for a local search planner LPG, on blocksworld (BW), logistics and mystery blocksworld domains. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Domain</td><td rowspan=\"2\">LLM</td><td colspan=\"3\">Avg. Search Steps</td><td colspan=\"3\">Avg. Plan Length</td><td rowspan=\"2\">Avg. Lev. Distance</td></tr><tr><td>Empty Seed</td><td>Random Seed</td><td>LLM Seed</td><td>Empty Seed</td><td>Random Seed</td><td>LLM Seed</td></tr><tr><td rowspan=\"2\">BW</td><td>I-GPT-3</td><td>Plan 15.8</td><td>Plan 20.07</td><td>Plan 14.5</td><td>Plan 8.45</td><td>Plan 9.62</td><td>Plan 11.7</td><td>7.22</td></tr><tr><td>GPT-4</td><td>15.8</td><td>20.07</td><td>8.9</td><td>8.45</td><td>9.62</td><td>10.76</td><td>4.15</td></tr><tr><td>Logistics</td><td>GPT-4</td><td>77.5</td><td>144.39</td><td>51.3</td><td>23.7</td><td>32.72</td><td>32.24</td><td>15.04</td></tr><tr><td>Mystery BW</td><td>GPT-4</td><td>15.8</td><td>20.45</td><td>16.09</td><td>8.45</td><td>9.78</td><td>11.53</td><td>7.77</td></tr></table>",
+        "bbox": [
+            199,
+            299,
+            794,
+            444
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Analyzing GPT-4 failures: To get a better sense of the type of failures LLM generated plans encounter, we wondered whether they will fare much better with a more forgiving test of the validity of the generated plans. In automated planning community, the notion of relaxations of the domain model are used to simplify the problem–chiefly to derive heuristics for planning problems [8]. Taking a leaf from them, we considered two types of relaxations: (i) delete relaxation involves ignoring all the delete conditions of the domain actions (thus making sure that there can be no negative interactions between subgoals) and (ii) precondition relaxation involves ignoring all the preconditions of the domain actions–thus assuming that the the actions are executable from any state giving their effects. Our idea is to evaluate the plans produced by GPT4 with respect to domain models that are delete relaxed, precondition relaxed or both. It should be clear that a plan that is correct with respect to the normal (unrelaxed) model will also be correct with respect to all the relaxed models. Figure 3 shows the results for blocksworld. We see that while the correctness of LLM generated plans increased under more forgiving (relaxed) assessments (area in green), even in the most lenient assessment mode (Delete+Precondition Relaxed), there still are plans $( \\sim 3 9 \\% )$ that are incorrect (because they still don’t reach the goals) across all the prompt configurations. The plots further classify the failure cases in terms of whether they were inexecutable, shown in maroon, or could be executed but didn’t reach the goals (shown in red). Note that when preconditions are relaxed, all plans are executable. We provide additional details on the relaxed assessments in Appendix A.2. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            708
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Evaluating LLMs as Idea Generators ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            727,
+            517,
+            744
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the preceding discussion establishes that LLMs are not capable of generating correct plans in autonomous mode, there is still the possibility that they can be useful idea generators for other sound external planners, verifiers or even humans-in-the-loop. In this section, we investigate this possibility and demonstrate that LLMs show promise on this front (especially with external planners and verfiers). ",
+        "bbox": [
+            174,
+            757,
+            825,
+            828
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 LLM Plans as Heuristics to Sound Planners ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            517,
+            858
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To see if the LLM generated plans can provide heuristic guidance to sound external planners, we use a local-search planner LPG [6] which generates plans by starting with a seed plan and iteratively repairing flaws until a correct plan is found. We feed the LLM-generated plan as the initial seed plan for LPG’s iterative search. Our hypothesis is that this might put LPG on the right path and reduce the time for it to generate a correct plan. It is interesting to note the similarities between this LLM+LPG approach, and the approaches used in case-based planning in the past [9, 17]. Here the LLM can be loosely viewed as “retrieving a potentially useful plan case/sketch” out of thin air, which the LPG adapts/corrects. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            160
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We utilized the plans that were generated by LLMs in the one-shot natural language prompt configuration on all three of our previous domains - Blocksworld, Mystery Blocksworld, and Logistics - as the \"seed plans\" from which LPG would begin its local search for a valid plan. For the Blocksworld domain, both GPT-4 and Instruct-GPT3 were evaluated, whereas for the Logistics and Mystery domains only GPT-4 was evaluated. We confirmed that all the plans that were generated by this LLM+LPG combination for both the domains were valid (which is as expected given that the underlying planner, LPG, is sound). To get an idea of how far the initial LLM generated plans were from the final correct solutions generated by LPG, we measured the Levenshtein edit distance between them. While the default LPG local search doesn’t aim to minimize the changes to the suggested plan (there do exist versions of LPG that do this; see [23]) , the edit distances also give an idea of how partially or approximately correct the original LLM plan is. Along with the edit distance, we also measured the number of search steps that were taken by the LPG to come up with a correct plan. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 3, the edit distances across domains are approximately half the length of the seed plans generated by the LLMs, indicating that $50 \\%$ of the final plan retains the elements of the initial LLM plan. For each problem, we performed two additional plan initializations to serve as baselines: initializing with an empty plan and initializing with a random plan of the same length as the plan generated by the LLM for that problem. In the Blocksworld and Logistics4 domains, we see a significant improvement in search steps over the empty seed plan when GPT-4 is used and an even larger one over the random seed plan. Consistent with our findings in the autonomous mode, the usefulness of this assistance wanes in domains where the relationships between predicates can no longer be inferred from common sense understandings of their names: in the Mystery Blocksworld domain, the LLM only has meager reduction in step size over the random plan and actually uses more steps than the empty plan. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            491
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 Verifier-assisted repeated backprompting of LLMs ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            511,
+            563,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The interaction between LLM and LPG was unidirectional–with LLM sending a seed plan that LPG aims to repair. One supposed advantage of LLMs is that they can be prompted to improve their solutions. Suppose we have access to a sound automated verifier that not only checks the plan correctness but also pinpoints faults (in terms of unsatisfied preconditions or delete interactions). Such feedback can be easily converted into a \"backprompt\" to the LLM, with the hope that LLM comes up with a better plan. This is what we do with the help of VAL[11]–an AI planning tool that uses the domain model to validate the correctness of the plans (and point out errors). ",
+        "bbox": [
+            174,
+            537,
+            483,
+            743
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/18b1ae26aa819b736735973f515d8ccf03ad1867eda6d6bbd9cdbaf7f783e61e.jpg",
+        "table_caption": [
+            "Table 4: GPT4 Performance with Backprompting by VAL [11]. Mystery BW had deceptive disguising. I.C - Instances correct (within 15 feedbacks); A.F.R - Avg. feedback rounds for correct instances. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Domain</td><td>1.C</td><td>A.FR</td></tr><tr><td>GPT-4</td><td>GPT-4</td></tr><tr><td>Blocksworld (BW)</td><td>41/50 (82%)</td><td>3.68</td></tr><tr><td>Logistics</td><td>35/50 (70%)</td><td>3.31</td></tr><tr><td>Mystery BW</td><td>5/50 (10%)</td><td>7.0</td></tr></table>",
+        "bbox": [
+            496,
+            616,
+            813,
+            717
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While, as we mentioned earlier, there can be thorny “clever hans” issues about humans prompting LLMs, an automated verifier mechanically backprompting the LLM doesn’t suffer from these. ",
+        "bbox": [
+            173,
+            751,
+            823,
+            780
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We tested this setup on a subset of the failed instances in the one-shot natural language prompt configuration using GPT-4, given its larger context window. We set a threshold of 15 backprompting rounds. We tested on three domains–Blocksworld, Logistics and Mystery BW–with 50 failed instances from each domain. Table 4 shows the results. We provide the prompt+feedback examples in Appendix A.9. We found that GPT4 is able to come up with correct plans $82 \\%$ of the Blocksworld instances and $70 \\%$ of the Logistics one. The average number of backprompting rounds for these successful cases was 3.68 for BW and 3.31 for Logistics. The performance on the Mystery BW however remained quite poor–suggesting that even with back prompting, GPT4 cannot do well unless it can tease out commonsense patterns for the domain. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this backprompting configuration, LLM serves as the candidate plan generator while VAL serves as the external sound verifier. While it is tempting to have a self-critiquing architecture with LLM also serving as the verifier, our recent work shows that approach to be of questionable utility as LLMs are no better at verifying plans than they are at generating them [36, 34]. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.3 LLMs as idea generators for humans-in-the-loop ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            212,
+            550,
+            227
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Along with external planners and verifiers, LLMs may also offer their insights as plan suggestions directly to the human-in-the-loop which might potentially guide the user to the correct plan. After all, this sort of computer supported cooperative work (CSCW) use case has been the staple of LLM applications. We explored the efficacy of LLMs in assisting human planners through a betweensubjects user study, structured similarly to the study outlined in Section 4, but with two primary distinctions: (1) The study involved two separate participant groups. The first group received no assistance in devising plans, paralleling the approach in Section 4, while the second group had access to LLM-generated suggestions. (2) both participant sets were asked to offer subjective feedback via the NASA-TLX assessment tool [10], gauging their cognitive load. Additionally, participants from the second group evaluated the correctness of the LLM suggestions presented to them. We utilized the plans generated by GPT-4 to provide plan suggestions. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            391
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The study included 49 participants in the unassisted group and 48 in the LLM-assisted group. We evaluated the statistical significance regarding accuracy, time taken, and cognitive load between the groups. Our findings revealed no statistical significance between the groups across all three aspects.5. Notably, 3 out of 48 participants mistakenly accepted incorrect LLM suggestions, with two submitting these erroneous suggestions as their plans. This shows the potential for automation bias in such methodologies [5]. We have provided the details of the user-study in Appendix A.12. ",
+        "bbox": [
+            174,
+            397,
+            825,
+            481
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            501,
+            449,
+            518
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we presented a critical investigation of the planning abilities of large language models (LLMs). To this end, we evaluated the plan generation abilities of LLMs in two different modes. In the autonomous mode, our results show that even in simple common-sense planning domains where humans could easily come up with plans, LLMs like GPT-3 exhibit a dismal performance. Even though there is an uptick in the performance by the newer GPT-4 in the blocksworld domain, it still fails miserably on the mystery blocksworld domain, indicating their inability to reason in an abstract manner. In the heuristic mode, we have seen that plans generated by LLMs can help improve the search of sound planners like LPG. Further, we showed that using external verifiers, we can point out the errors and back-prompt LLMs for a better plan. We showed that this indeed helps in common-sense domains. In the supplementary material, we show the prompt examples for all the configurations and the details of the user-studies (Appendix A.11). From our studies, we see that LLMs as autonomous planners fail miserably, but we also see that the generated plans improve the search when used by an underlying sound planner and that better plans can be obtained by back-prompting the LLM with feedback from an external verifier. ",
+        "bbox": [
+            173,
+            534,
+            826,
+            726
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            747,
+            367,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research was supported by ONR grants N00014-18-1-2442, N00014-18-1-2840, N00014- 19-1-2119 and N00014-23-1-2409, AFOSR grant FA9550-18-1-0067, DARPA SAIL-ON grant W911NF-19-2-0006, and a JP Morgan AI Faculty Research Grant to Kambhampati. Sreedharan was supported in part by NSF grant 2303019. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Clever Hans. https://en.wikipedia.org/wiki/Clever_Hans. ",
+        "bbox": [
+            181,
+            113,
+            581,
+            128
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[2] Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Keerthana Gopalakrishnan, Karol Hausman, Alex Herzog, et al. Do as i can, not as i say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.01691, 2022. ",
+        "bbox": [
+            178,
+            137,
+            826,
+            180
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[3] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020. ",
+        "bbox": [
+            178,
+            189,
+            825,
+            233
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[4] Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm: Scaling language modeling with pathways. arXiv preprint arXiv:2204.02311, 2022. ",
+        "bbox": [
+            179,
+            241,
+            825,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[5] Mary L Cummings. Automation bias in intelligent time critical decision support systems. In Decision making in aviation, pages 289–294. Routledge, 2017. ",
+        "bbox": [
+            178,
+            292,
+            825,
+            321
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[6] Alfonso Gerevini and Ivan Serina. Lpg: A planner based on local search for planning graphs with action costs. In AIPS, volume 2, pages 281–290, 2002. ",
+        "bbox": [
+            179,
+            330,
+            825,
+            359
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[7] Mor Geva, Daniel Khashabi, Elad Segal, Tushar Khot, Dan Roth, and Jonathan Berant. Did aristotle use a laptop? a question answering benchmark with implicit reasoning strategies. Transactions of the Association for Computational Linguistics, 9:346–361, 2021. ",
+        "bbox": [
+            179,
+            368,
+            821,
+            411
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[8] Malik Ghallab, Dana S. Nau, and Paolo Traverso. Automated Planning and Acting. Cambridge University Press, 2016. ",
+        "bbox": [
+            179,
+            420,
+            823,
+            449
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[9] Kristian J. Hammond. CHEF: A model of case-based planning. In Tom Kehler, editor, Proceedings of the 5th National Conference on Artificial Intelligence. Philadelphia, PA, USA, August 11-15, 1986. Volume 1: Science, pages 267–271. Morgan Kaufmann, 1986. ",
+        "bbox": [
+            179,
+            458,
+            825,
+            501
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[10] Sandra G Hart and Lowell E Staveland. Development of nasa-tlx (task load index): Results of empirical and theoretical research. Advances in psychology, 52:139–183, 1988. ",
+        "bbox": [
+            174,
+            510,
+            823,
+            540
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[11] Richard Howey, Derek Long, and Maria Fox. VAL: Automatic plan validation, continuous effects and mixed initiative planning using PDDL. In 16th IEEE International Conference on Tools with Artificial Intelligence, pages 294–301. IEEE, 2004. ",
+        "bbox": [
+            174,
+            547,
+            823,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[12] Wenlong Huang, Pieter Abbeel, Deepak Pathak, and Igor Mordatch. Language models as zero-shot planners: Extracting actionable knowledge for embodied agents. In International Conference on Machine Learning, pages 9118–9147. PMLR, 2022. ",
+        "bbox": [
+            174,
+            599,
+            823,
+            642
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[13] Wenlong Huang, Fei Xia, Ted Xiao, Harris Chan, Jacky Liang, Pete Florence, Andy Zeng, Jonathan Tompson, Igor Mordatch, Yevgen Chebotar, et al. Inner monologue: Embodied reasoning through planning with language models. arXiv preprint arXiv:2207.05608, 2022. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[14] IPC. International planning competition, 1998. ",
+        "bbox": [
+            176,
+            704,
+            516,
+            718
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[15] Liwei Jiang, Jena D. Hwang, Chandrasekhar Bhagavatula, Ronan Le Bras, Maxwell Forbes, Jon Borchardt, Jenny Liang, Oren Etzioni, Maarten Sap, and Yejin Choi. Delphi: Towards Machine Ethics and Norms. ArXiv, abs/2110.07574, 2021. ",
+        "bbox": [
+            174,
+            727,
+            823,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[16] Subbarao Kambhampati. AI as (an Ersatz) Natural Science? https://cacm.acm.org/blogs/blogcacm/261732-ai-as-an-ersatz-natural-science/fulltext, Jun 2022. ",
+        "bbox": [
+            171,
+            779,
+            825,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Subbarao Kambhampati and James A. Hendler. A validation-structure-based theory of plan modification and reuse. Artif. Intell., 55(2):193–258, 1992. ",
+        "bbox": [
+            171,
+            818,
+            825,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[18] Subbarao Kambhampati, Karthik Valmeekam, Matthew Marquez, and Lin Guan. On the role of large language models in planning, July 2023. Tutorial presented at the International Conference on Automated Planning and Scheduling (ICAPS), Prague. https://yochan-lab.github. io/tutorial/ICAPS-2023/. ",
+        "bbox": [
+            174,
+            856,
+            826,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[19] Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. Large Language Models are Zero-Shot Reasoners. arXiv preprint arXiv:2205.11916, 2022. ",
+        "bbox": [
+            169,
+            90,
+            823,
+            121
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[20] Paul Pu Liang, Chiyu Wu, Louis-Philippe Morency, and Ruslan Salakhutdinov. Towards understanding and mitigating social biases in language models. In International Conference on Machine Learning, pages 6565–6576. PMLR, 2021. ",
+        "bbox": [
+            174,
+            127,
+            821,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[21] Bo Liu, Yuqian Jiang, Xiaohan Zhang, Qiang Liu, Shiqi Zhang, Joydeep Biswas, and Peter Stone. Llm+ p: Empowering large language models with optimal planning proficiency. arXiv preprint arXiv:2304.11477, 2023. ",
+        "bbox": [
+            174,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Drew McDermott, Malik Ghallab, Adele E. Howe, Craig A. Knoblock, Ashwin Ram, Manuela M. Veloso, Daniel S. Weld, and David E. Wilkins. Pddl-the planning domain definition language. 1998. ",
+        "bbox": [
+            174,
+            229,
+            823,
+            271
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Tuan Anh Nguyen, Minh Do, Alfonso Emilio Gerevini, Ivan Serina, Biplav Srivastava, and Subbarao Kambhampati. Generating diverse plans to handle unknown and partially known user preferences. Artificial Intelligence, 190:1–31, 2012. ",
+        "bbox": [
+            173,
+            280,
+            823,
+            323
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] OpenAI. Introducing chatgpt by openai, 2022. ",
+        "bbox": [
+            174,
+            330,
+            516,
+            345
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] OpenAI. Gpt-4 technical report, 2023. ",
+        "bbox": [
+            176,
+            353,
+            462,
+            369
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Long Ouyang, Jeff Wu, Xu Jiang, Diogo Almeida, Carroll L Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. arXiv preprint arXiv:2203.02155, 2022. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            420
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. 2018. ",
+        "bbox": [
+            169,
+            426,
+            823,
+            457
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Shreyas Sundara Raman, Vanya Cohen, Eric Rosen, Ifrah Idrees, David Paulius, and Stefanie Tellex. Planning with large language models via corrective re-prompting. arXiv preprint arXiv:2211.09935, 2022. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            506
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An adversarial winograd schema challenge at scale. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 8732–8740, 2020. ",
+        "bbox": [
+            174,
+            515,
+            823,
+            558
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Patrick Schramowski, Cigdem Turan, Nico Andersen, Constantin A Rothkopf, and Kristian Kersting. Large pre-trained language models contain human-like biases of what is right and wrong to do. Nature Machine Intelligence, 4(3):258–268, 2022. ",
+        "bbox": [
+            173,
+            564,
+            823,
+            608
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Big Science. BigScience Large Open-science Open-access Multilingual Language Model. https://huggingface.co/bigscience/bloom, 2022. ",
+        "bbox": [
+            169,
+            614,
+            825,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Tom Silver, Varun Hariprasad, Reece S Shuttleworth, Nishanth Kumar, Tomás Lozano-Pérez, and Leslie Pack Kaelbling. PDDL planning with pretrained large language models. In NeurIPS 2022 Foundation Models for Decision Making Workshop, 2022. ",
+        "bbox": [
+            173,
+            652,
+            826,
+            695
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Aarohi Srivastava, Abhinav Rastogi, Abhishek Rao, Abu Awal Md Shoeb, Abubakar Abid, Adam Fisch, Adam R Brown, Adam Santoro, Aditya Gupta, Adrià Garriga-Alonso, et al. Beyond the imitation game: Quantifying and extrapolating the capabilities of language models. arXiv preprint arXiv:2206.04615, 2022. ",
+        "bbox": [
+            173,
+            703,
+            828,
+            760
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Kaya Stechly, Matthew Marquez, and Subbarao Kambhampati. Gpt-4 doesn’t know it’s wrong: An analysis of iterative prompting for reasoning problems. arXiv preprint arXiv:2310.12397, 2023. ",
+        "bbox": [
+            171,
+            767,
+            825,
+            810
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] Alon Talmor, Jonathan Herzig, Nicholas Lourie, and Jonathan Berant. Commonsenseqa: A question answering challenge targeting commonsense knowledge. arXiv preprint arXiv:1811.00937, 2018. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            861
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] Karthik Valmeekam, Matthew Marquez, and Subbarao Kambhampati. Can large language models really improve by self-critiquing their own plans? arXiv preprint arXiv:2310.08118, 2023. ",
+        "bbox": [
+            174,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Ed Chi, Quoc Le, and Denny Zhou. Chain of thought prompting elicits reasoning in large language models. arXiv preprint arXiv:2201.11903, 2022.   \n[38] Yaqi Xie, Chen Yu, Tongyao Zhu, Jinbin Bai, Ze Gong, and Harold Soh. Translating natural language to planning goals with large-language models. arXiv preprint arXiv:2302.05128, 2023.   \n[39] Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Representations, 2023.   \n[40] Honghua Zhang, Liunian Harold Li, Tao Meng, Kai-Wei Chang, and Guy Van den Broeck. On the paradox of learning to reason from data. arXiv preprint arXiv:2205.11502, 2022. ",
+        "bbox": [
+            171,
+            90,
+            826,
+            275
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/_h2FKc6E_YV/_h2FKc6E_YV.md

@@ -0,0 +1,279 @@
+# Rethinking and Scaling Up Graph Contrastive Learning: An Extremely Efficient Approach with Group Discrimination
+
+Yizhen Zheng1, Shirui $\mathbf { P a n } ^ { 2 }$ ∗, Vincent CS Lee1, Yu Zheng3, Phillip S. $\mathbf { V } \mathbf { u } ^ { 4 }$ ,   
+1Monash University, 2Griffith University, 3La Trobe University, 4 University of Illinons at Chicago   
+yizhen.zheng1@monash.edu, s.pan@griffth.edu.au, vincent.cs.lee@monash.edu yu.zheng@latrobe.edu.au, psyu@uic.edu
+
+# Abstract
+
+Graph contrastive learning (GCL) alleviates the heavy reliance on label information for graph representation learning (GRL) via self-supervised learning schemes. The core idea is to learn by maximising mutual information for similar instances, which requires similarity computation between two node instances. However, GCL is inefficient in both time and memory consumption. In addition, GCL normally requires a large number of training epochs to be well-trained on largescale datasets. Inspired by an observation of a technical defect (i.e., inappropriate usage of Sigmoid function) commonly used in two representative GCL works, DGI and MVGRL, we revisit GCL and introduce a new learning paradigm for self-supervised graph representation learning, namely, Group Discrimination (GD), and propose a novel GD-based method called Graph Group Discrimination (GGD). Instead of similarity computation, GGD directly discriminates two groups of node samples with a very simple binary cross-entropy loss. In addition, GGD requires much fewer training epochs to obtain competitive performance compared with GCL methods on large-scale datasets. These two advantages endow GGD with very efficient property. Extensive experiments show that GGD outperforms state-of-theart self-supervised methods on eight datasets. In particular, GGD can be trained in 0.18 seconds (6.44 seconds including data preprocessing) on ogbn-arxiv, which is orders of magnitude $^ { ( 1 0 , 0 0 0 + ) }$ faster than GCL baselines while consuming much less memory. Trained with 9 hours on ogbn-papers100M with billion edges, GGD outperforms its GCL counterparts in both accuracy and efficiency.
+
+# 1 Introduction
+
+Graph Neural Networks (GNNs) have been widely-adopted in learning representations for graphstructured data. By utilising message-passing over the topology of a graph, GNNs can learn effective low-dimensional node embeddings, which can be used for a variety of downstream tasks such as node classification [1]. GNNs have been further applied in diverse domains, e.g., federated learning [2, 3], trustworthy systems [4, 5], dynamic graphs [6, 7] and anomaly detection [8, 9].
+
+However, many GNNs adopt a supervised learning manner to train models with label information, which is expensive and labour-intensive to collect in real-world. To address this issue, a few studies (e.g., DGI [10], MVGRL [11], GMI [12], and GRACE [13]) borrow the idea of contrastive learning from computer vision (CV), and introduce graph contrastive learning (GCL) methods for selfsupervised GRL. The core idea of these methods is to maximise the mutual information (MI) between an anchor node and its positive counterparts, sharing similar semantic information while doing the opposite for negative counterparts as shown in Figure 1(a). Nonetheless, such a scheme relies on similarity calculation in contrastive loss computation. Additionally, GCL normally requires a large number of training epochs to be well-trained on large-scale datasets. Thus, when the size of the dataset is large, these methods require a significant amount of time and resources to be well-trained.
+
+Though a few GCL works attempt to improve graph contrastive learning with specially designed schemes, e.g., BGRL [15] and GBT [14], they are still inefficient and require high time consumption for model training. Inspired by BYOL [16], BGRL [15] adopts a bootstrapping scheme and remove negative node pairs. It only contrasts a node from the online network (i.e., updated with gradient) to its corresponding embedding from the target network (i.e., updated momentumly with stop gradient). Based on Barlow-Twins [17],
+
+![](images/95495bd797059e0d73a939f5afdde8d9b4ab6a0077dd735aea28b14bb0b91a6a.jpg)  
+Figure 1: The left subfigure shows the GCL learning scheme. Red line indicates MI maximisation between two nodes, each of which $\in \mathbb { R } ^ { 1 \times D }$ , while blue line indicates the opposite operation. The right subfigure presents Group Discrimination. It discriminates positive and negative node samples, each of which ∈ R1×1.
+
+GBT [14] borrows the idea of redundancy-reduction principle and utilises a cross-correlation-based loss to build contrastiveness between embedding dimensions.
+
+To boost training efficiency of self-supervised GRL, inspired by an observation of a technical defect (i.e., inappropriate application of Sigmoid function) in two representative GCL studies, we introduce a novel learning paradigm, namely, Group Discrimination (GD). Instead of similarity computation, GD directly discriminates a group of positive nodes from a group of negative nodes, as shown in Figure 1(b). Specifically, GD defines node samples generated with original graph as the positive group, while node samples obtained with corrupted topology are regarded as the negative group. Then, GD trains the model by classifying these node samples into the correct group with a very simple binary cross-entropy loss. By doing so, the model can extract valuable self-supervised signals from learning the edge distribution of a graph. Com
+
+Table 1: Training time in seconds comparison between GGD and GBT [14] (i.e., the most efficient GCL baseline as shown in section 5.1) on ogbnarxiv. Number in brackets means the hidden size. ‘Pre’, ‘Tr’ and ‘Epo’ indicate preprocessing time, training time per epoch, and the number of epochs for training GNNs. ‘Total(E)’ and ‘Total(T)’ are total end-to-end training time (i.e., including preprocessing), which equals to $( { \mathrm { P r e } } + { \mathrm { E p o } } \times { \mathrm { T r } } )$ and total training time, which is $( { \mathrm { E p o } } \times { \mathrm { T r } } )$ . ‘Imp(E)’ and $\mathrm { \cdot { I m p ( T ) } } ^ { \mathrm { , } }$ indicate how many times GGD improve on ‘Total(E)’ and ‘Total(T)’. ‘Acc’ is averaged accuracy result on test set over five runs.
+
+<table><tr><td>Method</td><td>Pre</td><td>Tr</td><td>Epo</td><td colspan="2">Total(E) Imp(E)</td><td colspan="2">Total(T)Imp(T)</td><td>Acc</td></tr><tr><td>GBT(256)</td><td>5.52</td><td>6.47</td><td>300</td><td>1,946.52</td><td>-</td><td>1,941.00</td><td>=</td><td>70.1</td></tr><tr><td>GGD(256)</td><td>6.26 0.18</td><td></td><td>1</td><td>6.44</td><td>302.25×</td><td>0.18</td><td>10,783.33x</td><td>70.3</td></tr><tr><td>GGD(1,500)</td><td></td><td>6.260.95</td><td>1</td><td>7.21</td><td>269.96×</td><td>0.95</td><td>2.043.16×</td><td>71.6</td></tr></table>
+
+pared with GCL, GD enjoys numerous merits including extremely fast training, fast convergence (e.g., 1 epoch to be well-trained on large-scale datasets), and high scalability while achieving SOTA performance with existing GCL approaches.
+
+Using GD as backbone, we design a new self-supervised GRL model with the Siamese structure called Graph Group Discrimination (GGD). Firstly, we can optionally augment a given graph with augmentation techniques, e.g., feature and edge dropout. Then, the augmented graph is fed into a GNN encoder and a projector to obtain embeddings for the positive group. After that, the augmented feature is corrupted with node shuffling (i.e., disarranging the order of nodes in the feature matrix) to disrupt the topology of a graph and input to the same network for obtaining embeddings of the opposing group. Finally, the model is trained by discriminating these two groups of node samples. The contributions of this paper are three-fold: 1) We re-examine existing GCL approaches (e.g., DGI [10] and MVGRL [11]), and we introduce a novel and efficient self-supervised GRL paradigm, namely, Group Discrimination (GD). 2) Based on GD, we propose a new self-supervised GRL model, GGD, which is fast in training and convergence, and possess high scalability. 3) We conduct extensive experiments on eight datasets, including an extremely large dataset, ogbn-papers100M with billion edges. The experiment results show that our proposed method reaches state-of-the-art performance while consuming much less time and memory than baselines, e.g., $\mathbf { 1 0 7 8 3 \times }$ faster than the most efficient GCL baseline with its best selected epochs number [14], as shown in Table 1.
+
+# 2 Rethinking Representative GCL Methods
+
+In this section, we analyse a technical defect observed in two representative GCL methods, DGI [10] and MVGRL [11]. Based on the technical defect, we show that mutual information maximisation behind these two approaches is not the contributed factor to contrastive learning, but a new paradigm, group discrimination. Finally, from the analysis, we provide the definition of this new concept.
+
+# 2.1 Rethinking GCL Methods
+
+DGI [10] is the first work introducing contrastive learning into GRL. However, due to a technical defect observed in their official opensource code, we found it is essentially not working as the authors thought (i.e., learning via MI interaction).
+
+![](images/e005a7bfab03de24a46df553ee290e45d447140dd4a7b74c7ad6162d90db0cd4.jpg)  
+Figure 2: The architecture of DGI. Cubes indicate node embeddings. Red and blue lines represent MI maximisation and minimisation, respectively. G and $\widetilde { \mathcal { G } }$ denote the original graph and the corrupted graph. s is the summary vector.
+
+Constant Summary Vector. As shown in Figure 2, the original idea of DGI is to maximise the MI (i.e., the red line) between a node $a$ and the summary vector s, which is obtained by averaging all node embeddings in a graph G. Also, to regularise the model training, DGI corrupts G by shuffling the node order of the input feature matrix to get G˜. Then, generated embeddings of $\widetilde { \mathcal { G } }$ serve as negative samples, which are pulled apart from the summary vector s via MI minimisation.
+
+Nonetheless, in the implementation of DGI, a Sigmoid function is inappropriately applied on the summary vector generated from a GNN whose weight is initialised with Xavier initialisation. As a result, elements in the summary vector are very close to the same value. We have validated this finding on three datasets, Cora, CiteSeer and PubMed. The experiment result is shown in Table 2, which shows that summary vec
+
+Table 2: Summary vector statistics on three datasets with different activation functions including ReLU, LeakyReLU (i.e., LReLU shown below), PReLU, and Sigmoid.   
+
+<table><tr><td>Activation</td><td>Statistics</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td></tr><tr><td rowspan="3">ReLU/LReLU/PReLU</td><td>Mean</td><td>0.50</td><td>0.50</td><td>0.50</td></tr><tr><td>Std</td><td>1.3e-03</td><td>1.0e-04</td><td>4.0e-04</td></tr><tr><td>Range</td><td>1.4e-03</td><td>8.0e-04</td><td>1.5e-03</td></tr><tr><td rowspan="3">Sigmoid</td><td>Mean</td><td>0.62</td><td>0.62</td><td>0.62</td></tr><tr><td>Std</td><td>5.4e-05</td><td>2.9e-05</td><td>6.6e-05</td></tr><tr><td>Range</td><td>3.6e-03</td><td>3.0e-03</td><td>3.2e-03</td></tr></table>
+
+tors in all datasets are approximately a constant vector $\epsilon I$ , where $\epsilon$ is a scalar and $\pmb { I }$ is an all-ones vector (i.e., $\scriptstyle \epsilon = 0 . 5 0$ with ReLU/LReLU/PReLU and $\epsilon { = } 0 . 6 2$ with Sigmoid as non-linear activation in these datasets).
+
+To theoretically explain this phenomenon, we present the proposition below:
+
+Table 3: The experiment result on three datasets with changing value from 0 to 1.0 for the summary vector.   
+
+<table><tr><td>Dataset</td><td>0</td><td>0.2</td><td>0.4</td><td>0.6</td><td>0.8</td><td>1.0</td></tr><tr><td>Cora</td><td></td><td></td><td></td><td></td><td>70.3±0.7 82.4±0.2 82.3±0.3 82.5±0.4 82.3±0.3 82.5±0.1</td><td></td></tr><tr><td>CiteSeer</td><td></td><td></td><td></td><td></td><td>61.8±0.8 71.7±0.6 71.9±0.7 71.6±0.9 71.7±1.0 71.6±0.8</td><td></td></tr><tr><td>PubMed</td><td>68.3±1.5 77.8±0.5 77.9±0.8 77.7±0.9 77.4±1.1 77.2±0.9</td><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+Proposition 1 Given $\mathcal { G } = \{ \mathbf { X } \in \mathbb { R } ^ { N \times D } , \mathbf { A } \in \mathbb { R } ^ { N \times N } \} ,$ and a GCN encoder $g ( \cdot )$ initialised with Xavier initialisation, we can obtain its embedding $\mathbf { H } = \sigma ( g ( \mathcal { G } ) )$ , where $\sigma ( \cdot )$ is a non-linear activation function. By applying the sigmoid function $\sigma _ { s i g } ( \cdot )$ to the summary vector s (i.e., the average row vector of H), values in $\sigma _ { s i g } ( \mathbf { s } )$ approximately become 0.5 with ReLU/LReLU/PReLU or 0.62 with Sigmoid as non-linear activation of $g ( \cdot )$ at the initialisation stage.
+
+Based on this proposition, we can see these summary vectors can lose variance and become a constant vector at the initialisation stage. Based on Table 2, we can see the constant in the summary vector remain unchanged, and the information loss still occurs even if the GNN encoder is trained. Thus, we conjecture the training process won’t affect the constant value much in the summary vector of DGI. The proof for the proposition is presented in Appendix A.1.
+
+To evaluate the effect of $\epsilon$ to constant summary vector, we vary the scalar $\epsilon$ (from 0 to 1 increment by 0.2) to change the constant summary vector and report the model performance (i.e., averaged accuracy on five runs) in Table 3.
+
+From this table, we can see, except for 0, the model performance is trivially affected by $\epsilon$ for constant summary vector. When the summary vector is set to 0, the model performance plummets because node embeddings become all 0 when multiplying with such vector and the model converges to the trivial solution. As the summary vector only has a trivial effect on model training, the hypothesis of DGI [10] on learning via contrastiveness between anchor nodes and the summary instance does not hold, which raises a question to be investigated: What truly leads to the success of DGI?
+
+Simplifying DGI. To answer the question, we predigest the objective function proposed in DGI (i.e., maximising the MI between $\mathbf { h } _ { i }$ and the summary vector s) by using an all-ones vector as the summary vector s (i.e., setting $\mathbf { s } = \epsilon \pmb { I } = \pmb { I }$ ) and simplifying the discriminator $\mathcal { D } ( \cdot )$ (i.e., removing the learnable weight matrix). Then, we rewrite the objective function to the following form:
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } _ { D G I } = \frac { 1 } { 2 N } ( \sum _ { i = 1 } ^ { N } \log \mathcal { D } ( \mathbf { h } _ { i } , \mathbf { s } ) + \log ( 1 - \mathcal { D } ( \tilde { \mathbf { h } } _ { i } , \mathbf { s } ) ) ) , } \\ { \displaystyle \qquad = \frac { 1 } { 2 N } ( \sum _ { i = 1 } ^ { N } \log ( \mathbf { h } _ { i } \cdot \mathbf { s } ) + \log ( 1 - \tilde { \mathbf { h } } _ { i } \cdot \mathbf { s } ) ) ) , } \\ { \displaystyle \qquad = \frac { 1 } { 2 N } ( \sum _ { i = 1 } ^ { N } \log ( s u m ( \mathbf { h } _ { i } ) ) + \log ( 1 - s u m ( \tilde { \mathbf { h } } _ { i } ) ) ) , } \end{array}
+$$
+
+where $\cdot$ is the vector multiplication operation, $N$ is the number of nodes in a graph, $\mathbf { h } _ { i } \in \mathbb { R } ^ { 1 \times D }$ and $\tilde { \mathbf { h } } _ { i } \in \mathbb { R } ^ { 1 \times D }$ are the original and corrupted embedding for node $i$ $, s u m ( \cdot )$ is the summation function, and $\mathcal { D } ( \cdot )$ is a discriminator for bilinear transformation, which can be formulated as follows:
+
+$$
+\begin{array} { r } { \mathrm { \bf ~ \mathcal { D } } ( { \bf h } _ { i } , { \bf s } ) = \sigma _ { s i g } ( { \bf h } _ { i } \cdot { \bf W } \cdot { \bf s } ) , } \end{array}
+$$
+
+where $\mathbf { W }$ is a learnable weight matrix and $\sigma _ { s i g } ( \cdot )$ is the sigmoid function. Specifically, as shown in Equation 2, by removing the weight matrix $\mathbf { W } ,  { \mathbf { h } } _ { i }$ is directly multiplied with s. As s is a vector containing only one, the multiplication of $\mathbf { h } _ { i }$ and s is equivalent to summing $\mathbf { h } _ { i }$ itself directly. From this form, we can see that the multiplication of $\mathbf { h } _ { i }$ and the summary vector only serves as an aggregation function (i.e., summation aggregation) to aggregate $\mathbf { h } _ { i }$ . To explore the effect of other aggregation functions, we replace the summation function in Equation 1 with other aggregation methods such as mean-, minimum-, and maximum- pooling, and present the experiment result in Appendix A.3.
+
+Table 4: Comparison of the original DGI and $\mathrm { D G I } _ { B C E }$ in terms of accuracy (averaged on five runs), memory efficiency (in MB) and training time (in seconds). Number after | shows how many times have $\mathrm { D G I } _ { B C E }$ improved on top of DGI.
+
+<table><tr><td>Experiment</td><td>Method</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td></tr><tr><td>Accuracy</td><td>DGI</td><td>81.7±0.6</td><td>71.5±0.7</td><td>77.3±0.6</td></tr><tr><td></td><td>DGIBCE</td><td>82.5±0.3</td><td>71.7±0.6</td><td>77.7±0.5</td></tr><tr><td>Memory</td><td>DGI</td><td>4189MB</td><td>8199MB</td><td>11471MB</td></tr><tr><td></td><td>DGIBCE</td><td></td><td></td><td>1475MBl64.8%1587MBl80.6%1629MBl85.8%</td></tr><tr><td>Time</td><td>DGI</td><td>0.085s</td><td>0.134s</td><td>0.158s</td></tr><tr><td></td><td>DGIBCE</td><td>0.010sl8.5×</td><td>0.021sl6.4×</td><td>0.015sl10.5×</td></tr></table>
+
+Based on Equation 1, we can rewrite it to a very simple binary cross entropy loss if we also include corrupted nodes as data samples and setting ${ \hat { y } } _ { i } = a g g ( \mathbf { h } _ { i } )$ , where $a g g ( \cdot )$ stands for aggregation:
+
+$$
+\mathcal { L } _ { B C E } = - \frac { 1 } { 2 N } ( \sum _ { i = 1 } ^ { 2 N } y _ { i } \log \hat { y } _ { i } + ( 1 - y _ { i } ) \log ( 1 - \hat { y } _ { i } ) ) ,
+$$
+
+where $y _ { i } \in \mathbb { R } ^ { 1 \times 1 }$ means the indicator for node $i$ (i.e., if node $i$ is corrupted, $y _ { i }$ is 0, otherwise it is 1), and $\hat { y } _ { i } \in \mathbb { R } ^ { 1 \times 1 }$ represents the prediction for a node sample $i$ . As we include corrupted nodes as data samples, the size of nodes to be processed is doubled to $2 N$ (i.e., the number of corrupted nodes is equal to the number of original nodes). From the equation above, we can easily observe that what DGI truly does is discriminate between a group of nodes generated with correct topology and nodes generated with corrupted topology, as shown in Figure 1. We name this self-supervised learning paradigm "Group Discrimination". To validate the effectiveness of this paradigm, we replace the original DGI loss with Equation 3, namely, $\mathrm { D G I } _ { B C E }$ and compare it with DGI on three datasets in terms of training time, memory efficiency and model performance as shown in Table 4. Here, $\mathrm { D G I } _ { B C E }$ adopts the same parameter setting as DGI. From this table, we can observe $\mathrm { D G I } _ { B C E }$ dramatically improves DGI in both memory and time efficiency while it slightly enhances the model performance of DGI. This may be contributed to the removal of multiplication operations between node pairs, which eases the burden of computation and memory consumption.
+
+Similar to DGI, the same technical defect is observed in MVGRL [11], which makes it become a GD-based method. Extended on DGI, MVGRL [11] incorporates diffusion augmentation to inject additional global information into model training, which enhances the model performance. The detailed analysis for MVGRL is presented in Appendix A.4.
+
+# 2.2 Definition of Group Discrimination
+
+As mentioned above, Group Discrimination is a self-supervised GRL paradigm, which learns by discriminating different groups of node samples. Specifically, the paradigm assigns different indicators to different groups of node samples. For example, for binary group discrimination, one group is considered as the positive group with class 1 as its indicator, whereas the other group is the negative group, having its indicator assigned as 0. Given a graph G, the positive group usually includes node samples generated with the original graph G or its augmented views (i.e., similar graph instances of G created by augmentation). In contrast, the opposing group contains negative samples obtained by corrupting G, e.g., changing its topology structure.
+
+Based on our theoretical analysis, group discrimination is learning to avoid making ‘mistakes’ (i.e., bias the encoder towards avoiding mistaken samples), thus improving the quality of generated embeddings. The analysis and an intuitive explanation are presented in Section 6.1.1 and A.2.1.
+
+# 3 Methodology
+
+We first define unsupervised node representation learning and then present the architecture of GGD, which extends $\mathbf { D G I } _ { B C E }$ with additional augmentation, the projector and embedding reinforcement to reach better model performance. Given a graph G with attributes $\mathbf { X } \in \mathbb { R } ^ { N \times D }$ , where $N$ is the number of nodes in G, and $D$ is the number of dimensions of $\mathbf { X }$ , our aim is to train a GNN encoder without the reliance on labelling information. With the trained encoder, taking G and $\mathbf { X }$ as input, it can output learned representations $\mathbf { H } \in \mathbb { R } ^ { N \times D ^ { \prime } }$ , where $D ^ { \prime }$ is the predefined hidden dimension. H can then be used in many downstream tasks such as node classification.
+
+![](images/35924d1789fec858cdd0bc17c036fbafa43902aba9cf673742249a05da6a4c9a.jpg)
+
+Figure 3: The architecture of GGD. Given a graph G with a feature matrix $\mathbf { X }$ , we can optionally apply augmentation on them to generate $\hat { \mathcal G }$ and $\hat { \mathbf X }$ . Then, we corrupt $\hat { \mathbf { X } }$ and $\hat { \mathcal G }$ to obtain $\tilde { \mathbf { X } }$ and G˜. Taking $\dot { \hat { \mathbf { X } } }$ and $\hat { \mathcal G }$ as input to the encoder and the projector, i.e., a multilayer perceptron, positive node samples can be obtained. Similarly, $\tilde { \mathbf { X } }$ and $\tilde { \mathcal { G } }$ are fed to the same encoder and projector to generate negative samples. The generated embeddings are aggregated to get predictions for the group discrimination task. This process will be iteratively conducted until reaching the predefined training epochs.
+
+# 3.1 Graph Group Discrimination
+
+Based on the proposed self-supervised GRL paradigm, group discrimination, we have designed a novel method, namely GGD, to learn node representations using a siamese network structure and a BCE loss. The architecture of GGD is presented in Figure 3. The framework mainly consists of four components: augmentation, corruption, a siamese GNN network, and group discrimination.
+
+Augmentation. With a given graph G and feature matrix $\mathbf { X }$ , optionally, we can augment it with augmentation techniques such as edge and feature dropout to create $\hat { \mathcal G }$ and $\hat { \mathbf X }$ . In practice, we follow the augmentation proposed in GraphCL [18]. Specifically, edge dropout removes a predefined fraction of edges, while we use node dropout to mask a predefined proportion of feature dimension, i.e., assigning 0 to replace values in randomly selected dimensions. This step is optional in implementation.
+
+Notably, the motivation of using augmentation in our framework is distinct from contrastive learning methods. In our study, augmentation is used to increase the difficulty of the self-supervised training tasks. With augmentation, $\hat { \mathcal G }$ and $\hat { \mathbf { X } }$ change in every training iteration, which forces the model to lessen the dependence on the fixed pattern (i.e., unchanged edge and feature distribution) in a monotonous graph. However, in contrastive learning, augmentation creates augmented views sharing similar semantic information for building contrastiveness.
+
+Corruption. $\hat { \mathcal G }$ and $\hat { \mathbf X }$ are then corrupted to build $\tilde { \mathcal { G } }$ and $\tilde { \mathbf { X } }$ for the generation of node embeddings in the negative group. We adopt the same corruption technique used in DGI [10] and MVGRL [11] (as shown in Figure 5). The corruption technique devastates the topology structure of $\hat { \mathcal G }$ by randomly changing the order of nodes in $\hat { \mathbf { X } }$ . The corrupted $\tilde { \mathbf { X } }$ and $\tilde { \mathcal { G } }$ can be used for producing node representations with incorrect network connections.
+
+The Siamese GNN. We have designed a siamese GNN network to output node representations given a graph and its attribute. The siamese GNN network is made up of two components, which are a GNN encoder and a projector. The backbone GNN encoder is replaceable with a variety of choices of GNNs, e.g., GCN [19] and GAT [20]. In our work, we adopt GCN as the backbone. The projector is a multi-layer perceptron network, whose number of layers can be adjusted. When generating node embeddings of the positive group, the Siamese network takes $\hat { \mathcal G }$ and $\hat { \mathbf { X } }$ as input. Using the same encoder and projector, the Siamese network output the negative group with $\bar { \mathfrak { G } }$ and $\tilde { \mathbf { X } }$ . These two groups of node embeddings are considered as a collection of data samples with a size of $2 N$ for discrimination. Before conducting group discrimination, in the “aggregation” phase, all data samples are aggregated with the same aggregation technique, e.g., sum-, mean-, and linear aggregation.
+
+Group Discrimination. In the group discrimination process, we adopt a very simple binary cross entropy (BCE) loss to discriminate two groups of node samples as shown in Equation 3. In our implementation, $y _ { i }$ is 0 and 1 for node embeddings in negative and positive groups. During model training, the model is optimised by categorising node embeddings in the collection of data samples into their corresponding class correctly. The loss is computed by comparing the prediction of a node $i$ , i.e., a scalar, with its indicator $y _ { i }$ . With the ease of BCE loss computation, the training process of GGD is very fast and memory efficient.
+
+# 3.2 Model Inference
+
+During training, the model is optimised via loss minimisation with Equation 3. The time complexity analysis of GGD is provided in Appendix A.5. In the inference phase, we freeze the trained GNN encoder $g _ { \theta }$ and obtain node embeddings $\mathbf { H } _ { \theta }$ with the input G.
+
+Inspired by MVGRL [11], which strengthens the output embeddings by including additional global information, we adopt a conceptually similar embedding reinforcement approach. Specifically, they obtain the final embeddings by summing up embeddings from two views: the original view comprising local information and the diffused view with global information. This operation reinforces the final embeddings and leads to model performance improvement. Nonetheless, graph diffusion impairs the scalability of a model [21] and hence cannot be directly applied in our embedding generation process. To avoid the diffusion computation, we have come up with a workaround in the virtue of the power of a graph to extract global information. The power of a graph can extend the message passing scope of $\mathbf { H } _ { \theta }$ to n-hop neighbourhood, which encodes global information from distant neighbours. It can be formulated as follows:
+
+$$
+\begin{array} { r } { \mathbf { H } _ { \theta } ^ { g l o b a l } = \mathbf { A } ^ { n } \mathbf { H } _ { \theta } , } \end{array}
+$$
+
+where Hglobal is the global embedding, and $\mathbf { A }$ is the adjacency matrix of the graph G. It is notable that this operation can be easily decomposed with the associative property of matrix multiplication and is easy to compute. To show the easiness of such computation, we conduct an experiment showing its time consumption on various datasets in Appendix A.6. Finally, the final embedding can be achieved by $\mathbf { H } = \mathbf { H } _ { \theta } ^ { g l o \bar { b } a l } + \mathbf { H } _ { \theta }$ , which can be used for downstream tasks. In our experiment, we conduct node classification tasks. Following the common practice of GCL methods [10, 13, 15, 12, 17], these tasks are performed by using the final embeddings $\mathbf { H }$ to train and test a simple logistic regression classifier.
+
+# 4 Related Work
+
+Graph Neural Networks (GNNs). are generalised deep neural networks for graph-structured data. GNNs mainly have two categories, spectral-based GNNs and spatial-based GNNs. Spectral GNNs attempt to use eigen-decomposition to obtain the spectral-based representation of graphs, whereas spatial GNNs focus on using spatial neighbours of nodes for message passing. Extending spectral-based methods to the spatial domain, GCN [19] utilises first-order Chebyshev polynomial filters to approximate spectral-based graph convolution. Taking the weight of spatial neighbours in consideration, GAT [20], improves GCN by introducing attention module in message passing. To decouple message passing from neural networks, SGC [22] simplifies GCN by removing non-linearity and weight matrices in graph convolution layers. However, these studies cannot handle datasets with limited or no labels. Graph contrastive learning has been recently exploited to address this issue.
+
+Graph Contrastive Learning (GCL). aims to alleviate the reliance on labelling information in model training based on the concept of mutual information (MI). Specifically, GCL approaches maximise MI between instances with similar semantic information, and minimise MI between dissimilar instances. For example, DGI [10] builds contrastiveness between node embeddings and a summary vector (i.e., a graph level embedding obtained by averaging all node embeddings) with a JSD estimator. To improve DGI, MVGRL [11] and GMI [12] extends the idea of DGI by introducing multi-view contrastiveness with diffusion augmentation, and focusing on a local scope with the first-order neighbourhood, respectively. Adopting InfoNCE loss, GRACE [13] applies augmentation techniques to create two augmented views and inject contrastiveness between them. Though these GCL methods have successfully outperformed some supervised baselines in benchmark datasets, these methods suffer from significant limitations, including time-consuming training, memory inefficiency, and poor scalability. In contrast, GGD requires much less time in training and posses high scalability.
+
+Scalable GNNs. Efficiency is a bottleneck for most existing GNNs to handle large graphs. To address this challenge, there are mainly three categories of approaches: layer-wise sampling (e.g., GraphSage [23]), graph sampling methods such as Cluster-GCN [24] and GraphSAINT [25], and linear models, e.g., SGC [22] and PPRGo [26]. GraphSage [23] introduces a neighbour-sampling approach, which creates fixed-size subgraphs for each node. Underpinned by graph sampling, Cluster-GCN [24] decomposes a large-scale graph into multiple subgraphs based on clustering, while GraphSAINT [25] utilises light-weight graph samplers along with a normalisation technique for biases elimination in mini-batches. Linear models, SGC [22] and PPRGo [26], decouple graph convolution from embedding transformation (i.e., matrix multiplication with weight matrices), and leverage Personalised PageRank to encode multi-hop neighbourhood, respectively. However, all these methods only focus on supervised learning on graphs. For unsupervised/self-supervised learning settings where no labelled supervision signal is available, these frameworks are not applicable. The closest works to ours to handle large scale graph datasets under self-supervised settings are BGRL [15] and GBT [14]. They try to improve the contrastive losses by removing negative samples. However, BGRL [15] and GBT [14] still require much more time in training compared with GGD.
+
+# 5 Experiments
+
+We evaluate the effectiveness of our model using eight benchmark datasets of different sizes. These datasets include five small- and mediumscale datasets: Cora, CiteSeer, PubMed [27], Amazon Computers, and Amazon Photos [28], as well as large-scale datasets ogbn-arxiv, ogbnproducts and ogbn-papers100M. Notably, ogbnpapers100M is the largest dataset provided by Open Graph Benchmark[29] for node property prediction tasks. It has over 110 million nodes and 1 billion edges. The statistics of these datasets are summarised in Appendix A.7. To
+
+Table 5: Model performance of node classification on 5 datasets. X, A and Y represent feature, adjacency matrix, and labels. Best performance for each dataset is in bold. Comp and Photo refer to Amazon Computers and Amazon Photos.   
+
+<table><tr><td>Data</td><td>Method</td><td>Cora</td><td></td><td>CiteSeer PubMed</td><td>Comp</td><td>Photo</td></tr><tr><td>X,A,Y</td><td>GCN</td><td>81.5</td><td>70.3</td><td>79.0</td><td></td><td>76.3±0.5 87.3±1.0</td></tr><tr><td>X,A,Y</td><td>GAT</td><td>83.0±0.7 72.5±0.7 79.0±0.3 79.3±1.1 86.2±1.5</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A,Y</td><td>SGC</td><td>81.0±0.0 71.9±0.1 78.9±0.0 74.4±0.1 86.4±0.0</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A,Y</td><td>CG3</td><td>83.4±0.7 73.6±0.8 80.2±0.8 79.9±0.6 89.4±0.5</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A</td><td>DGI</td><td>81.7±0.6 71.5±0.7 77.3±0.6 75.9±0.6 83.1±0.5</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A</td><td>GMI</td><td>82.7±0.2 73.0±0.3 80.1±0.2 76.8±0.1 85.1±0.1</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A</td><td>MVGRL</td><td>82.9±0.7 72.6±0.7 79.4±0.3 79.0±0.6 87.3±0.3</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A</td><td>GRACE</td><td></td><td></td><td></td><td></td><td>80.0±0.4 71.7±0.6 79.5±1.1 71.8±0.4 81.8±1.0</td></tr><tr><td>X,A</td><td>GraphCL</td><td>82.5±0.2 72.8±0.3 77.5±0.2 OOM</td><td></td><td></td><td></td><td>79.5±0.4</td></tr><tr><td>X,A</td><td>BGRL</td><td></td><td></td><td></td><td></td><td>80.5±1.0 71.0±1.2 79.5±0.6 89.2±0.9 91.2±0.8</td></tr><tr><td>X,A</td><td>GBT</td><td></td><td></td><td></td><td>81.0±0.5 70.8±0.2 79.0±0.1 88.5±1.0 91.1±0.7</td><td></td></tr><tr><td>X,A</td><td>GGD</td><td></td><td></td><td></td><td>83.9±0.4 73.0±0.6 81.3±0.8 90.1±0.9 92.5±0.6</td><td></td></tr></table>
+
+ensure reproducibility, the detailed experiment settings and computing infrastructure are summarised in Appendix A.8. The source code is already open sourced2.
+
+# 5.1 Evaluating on Small- and Medium-scale Datasets
+
+We compare GGD with ten baselines including four supervised GNNs (i.e., GCN [19], GAT [20], SGC [22], and CG3 [30]) and six GCL methods (i.e., DGI [10], GMI [12], MVGRL [11], GRACE [13], BGRL [15] and GBT [14]) on five small- and medium scale benchmark datasets. In the experiment, we follow the same data splits as [31] for Cora, CiteSeer and PubMed. For Amazon Computers and Photos, we use a random split setting, which randomly allocates $10 / 1 0 / 8 0 \%$ of data to training/validation/test set, respectively. The model performance is measured using the averaged
+
+Table 6: Comparison of training time per epoch in seconds between six GCL-based methods and GGD on five datasets. Improve means how many times are GGD faster than baselines. ‘-’ means the improvement range.   
+
+<table><tr><td>Method</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td><td>Comp</td><td>Photo</td></tr><tr><td>DGI</td><td>0.085</td><td>0.134</td><td>0.158</td><td>0.171</td><td>0.059</td></tr><tr><td>GMI</td><td>0.394</td><td>0.497</td><td>2.285</td><td>1.297</td><td>0.637</td></tr><tr><td>MVGRL</td><td>0.123</td><td>0.171</td><td>0.488</td><td>0.663</td><td>0.468</td></tr><tr><td>GRACE</td><td>0.056</td><td>0.092</td><td>0.893</td><td>0.546</td><td>0.203</td></tr><tr><td>GraphCL</td><td>0.073</td><td>0.085</td><td>0.123</td><td>OOM</td><td>0.188</td></tr><tr><td>BGRL</td><td>0.085</td><td>0.094</td><td>0.147</td><td>0.337</td><td>0.273</td></tr><tr><td>GBT</td><td>0.073</td><td>0.072</td><td>0.103</td><td>0.492</td><td>0.173</td></tr><tr><td>GGD</td><td>0.010</td><td>0.021</td><td>0.015</td><td>0.016</td><td>0.009</td></tr><tr><td>Improve</td><td>7.3-39.4×</td><td>3.4-23.7×</td><td>6.9-152.3×</td><td>10.7-15.3×</td><td>19.2-70.8x</td></tr></table>
+
+classification accuracy with five results along with standard deviations and reported in Table 5.
+
+Accuracy. From Table 5, we can observe that GGD generally outperforms all baselines in all datasets. The only exception is on CiteSeer dataset, where the semi-supervised method, CG3[30], slightly outperforms GGD, which still provides the 2nd best performance. In this experiment, we use the officially released code of GraphCL [18], BGRL [15] and GBT [14] to reproduce the result, while the other results are sourced from previous studies [30, 1].
+
+# Efficiency and Memory Consumption. GGD is
+
+Table 7: Comparison of memory consumption in MBs of six GCL baselines and GGD on five datasets.   
+
+<table><tr><td>Method</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td><td>Comp</td><td>Photo</td></tr><tr><td>DGI</td><td>4,189</td><td>8,199</td><td>11,471</td><td>7,991</td><td>4.946</td></tr><tr><td>GMI</td><td>4,527</td><td>5,467</td><td>14.697</td><td>10.655</td><td>5,219</td></tr><tr><td>MVGRL</td><td>5,381</td><td>5,429</td><td>6.619</td><td>6.645</td><td>6.645</td></tr><tr><td>GRACE</td><td>1,913</td><td>2.043</td><td>12.597</td><td>8,129</td><td>4,881</td></tr><tr><td>GraphCL</td><td>4,163</td><td>8,249</td><td>11,555</td><td>OOM</td><td>9.083</td></tr><tr><td>BGRL</td><td>1,627</td><td>1,749</td><td>2.299</td><td>5.069</td><td>3.303</td></tr><tr><td>GBT</td><td>1,651</td><td>1,799</td><td>2,461</td><td>5.037</td><td>2.641</td></tr><tr><td>GGD</td><td>1,475</td><td>1,587</td><td>1,629</td><td>1,787</td><td>1,637</td></tr><tr><td>Improve</td><td>10.7-72.6%</td><td>11.8-80.6%</td><td>27.2-85.8%</td><td>64.5-83.2%</td><td>38.0-75.4%</td></tr></table>
+
+substantially more efficient than other self-supervised baselines in time and memory consumption as shown in Table 6 and Table 7. Remarkably, GGD is 19.2 times faster in Amazon Photos for training time per epoch, and consumes $6 4 . 5 \%$ less memory in Amazon Computers for memory consumption than the most efficient baseline (i.e., GBT [14]). The dramatic boost of time and memory efficiency of GGD is contributed to the exclusion of similarity computation, which enables model training without multiplication of node embeddings.
+
+# 5.2 Evaluating on Large-scale datasets
+
+To evaluate the scalability of GGD, we choose three large-scale datasets from Open Graph Benchmark [29], which are ogbn-arxiv, ogbn-products, and ogbn-papers100M. ogbn-papers100M is the most challenging large-scale graph available in Open Graph Benchmark for node property prediction with over 1 billion edges and 110 million nodes. Extending to extremely large graphs (i.e., ogbnproducts and ogbn-papers100M), we adopt a Neighbourhood Sampling strategy, which is described in Appendix A.8.
+
+ogbn-arxiv & ogbn-products. For ogbn-arxiv, we compare GGD against four self-supervised baselines (i.e., DGI [10], GRACE [13], BGRL [15]and GBT [14]), whereas BGRL [15] and GBT [14] are selected to be compared for ogbn-products. In addition, we include the performance of MLP, Node2vec [32], and supervised GCN [19] sourced from [29] in Table 8 and Table 9. For memory and training time comparison, we only compare GGD with the two most efficient baselines (i.e., BGRL and GBT according to Tables 6 and 7). In ogbn-arxiv, we reproduce BGRL [15] and found it fails to process
+
+Table 8: Node classification result and efficiency comparison on ogbn-arxiv. ‘epo’ means epoch. ‘Time’ means training time per epoch (in seconds). ‘Total’ is total training time (Number of epochs $\times$ ‘Time’). OOM indicates out-of-memory on Nvidia A40 (48GB). Number after \ means the hidden size of GGD.   
+
+<table><tr><td>Method</td><td>Valid</td><td>Memory</td><td>Time</td><td>Total</td></tr><tr><td>Supervised GCN</td><td>73.0±0.2 71.7±0.3</td><td></td><td>=</td><td></td></tr><tr><td>MLP</td><td>57.7±0.4 55.5±0.2</td><td></td><td></td><td></td></tr><tr><td>Node2vec</td><td>71.3±0.1 70.1±0.1</td><td></td><td></td><td></td></tr><tr><td>DGI</td><td>71.3±0.1 70.3±0.2</td><td></td><td></td><td></td></tr><tr><td>GRACE(10k epos)</td><td>72.6±0.2 71.5±0.1</td><td></td><td></td><td></td></tr><tr><td>BGRL(10k epos)</td><td>72.5±0.1 71.6±0.1</td><td>OOM (Full-graph)</td><td>/</td><td>/</td></tr><tr><td>GBT(300 epos)</td><td>71.0±0.1 70.1±0.2</td><td>14.959MB</td><td></td><td>6.47 1,941.00</td></tr><tr><td>GGD(1 epo\1500)</td><td>72.7±0.3 71.6±0.5</td><td>14.666MB</td><td></td><td>0.95 0.9512.043×</td></tr><tr><td>GGD(1 epo\256)</td><td>71.0±0.2 70.3±0.3</td><td>4,513MBl69.8%</td><td></td><td>0.18 0.18|10,783×</td></tr></table>
+
+ogbn-arxiv in full batch. Thus, we only compare GGD and GBT in this dataset, which can successfully train in full-graph processing mode.
+
+From Table 8 and Table 9, we can see GGD remarkably achieves the state-of-the-art performance using only one epoch to train. As a result, GGD is 10,783 times faster than the most efficient baseline, i.e., GBT [14], on total training time to reach the desirable performance in ogbn-arxiv. Please note that the number of epoches in our experiment is consistent with the optimal choice
+
+Table 9: Node classification result and efficiency comparison on ogbn-products.   
+
+<table><tr><td>Method</td><td>Valid</td><td>Test</td><td>Memory</td><td>Time</td><td>Total</td></tr><tr><td>Supervised GCN</td><td>92.0±0.0</td><td>75.6±0.2</td><td>-</td><td>-</td><td></td></tr><tr><td>MLP</td><td>75.5±0.0</td><td>61.1±0.0</td><td></td><td></td><td></td></tr><tr><td>Node2vec</td><td>70.0±0.0</td><td>68.8±0.0</td><td></td><td></td><td></td></tr><tr><td>BGRL(100 epos)</td><td>78.1±2.1</td><td>64.0±1.6</td><td>29,303MB</td><td></td><td>53m16s 5.326m40s</td></tr><tr><td>GBT(100 epos)</td><td>85.0±0.1</td><td>70.5±0.4</td><td>20.419MB</td><td></td><td>48m38s 4.863m20s</td></tr><tr><td>GGD(1 epo)</td><td>90.9±0.5</td><td>75.7±0.4</td><td>4,391MBl78.5%12m46s 12m46sl381x</td><td></td><td></td></tr></table>
+
+of this hyperparameter specified in GBT [14]. For ogbn-products, we are $3 8 1 \mathrm { ~ \times ~ }$ faster than GBT [14] on total training time. Notably, our performance is significantly higher than GCL baselines using 100 epochs (i.e., $6 \%$ and $5 . 2 \%$ improvement on GBT [14] in validation and test set, respectively) with only one epoch training in this dataset. In addition, we compare the convergence speed among GGD, BGRL [15] and GBT [14] on ogbn-arxiv and ogbn-products, which are shown in Figure 4. For ogbn-arxiv, BGRL [15] is running using batched processing with neighbour sampling. This figure shows the preeminence of our GGD in convergence speed as GGD can be well-trained with only one epoch (i.e., reaching the peak model performance in the first epoch and staying stable with increased epochs). In contrast, the other two baselines require comparatively much more epochs to gradually improve their performance. Compared with GCL baselines, GGD achieves much faster convergence via Group Discrimination. We conjecture this is because GD-based method focuses on the general edge distribution of graphs instead of node-specific information. Inversely, GCL methods can suffer from convergence inefficiency as they may be easily distracted from too-detailed node-specific information during training.
+
+ogbn-papers100M. We further compare GGD with BGRL [15] and GBT [14] on ogbn-papers100M, the largest OGB dataset with billion scale edges. Other self-supervised learning algorithms such as DGI [10] and GMI [12] fail to scale to such a large graph with a reasonable batch size (i.e., 256). We only report the performance of each algorithm after a single epoch of training in Table 10 due to the extreme scale of the dataset and the limitation of our available re
+
+![](images/369404741420a9881e06aace9ef0fa35449dda32773f5aba54e1e7e7eefff56b.jpg)  
+Figure 4: Convergence speed comparison among GGD, BGRL[15] and GBT [14]. X-axis means number of epochs, while Y-axis represents the accuracy on test set.
+
+sources. From the table, we can observe that GGD outperforms the two GCL counterparts, BGRL [15] and GBT [14] in both accuracy and efficiency. Specifically, GGD achieves 60.2 in accuracy while BGRL and GBT reach 59.3 and 58.9 in test set, respectively. With only one epoch, these two algorithms may not be well trained. However, training each epoch of these two requires over 1 day and if we would like to train them for 100 epochs, then we will need $1 0 0 +$ GPU days, which is prohibitively impractical for general practitioners. In contrast, GGD can be trained in about 9 hours to achieve a good result for this dataset, which is more appealing in practice.
+
+# 6 Explore Group Discrimination
+
+In this section, we explore the corruption technique in GGD and provide the theoretical analysis of group discrimination.
+
+# 6.1 Exploring Corruption
+
+Firstly, we explore the corruption technique used in DGI [10] and MVGRL [11], which is shown in Figure 5. These two studies corrupt the topology of a given graph G by shuffling the feature matrix $\mathbf { X }$ . This is because by changing the node order of $\mathbf { X }$ , the neighbouring structure of G is completely changed, e.g., neighbours of node $a$ become node $b$ neighbours.
+
+Table 10: Node classification result and efficiency comparison on ogbn-papers100M.   
+
+<table><tr><td>Method</td><td>Validation</td><td>Test</td><td>Memory</td><td>Time</td></tr><tr><td>Supervised SGC</td><td>63.3±0.2</td><td>66.5±0.2|</td><td>-</td><td>-</td></tr><tr><td>MLP</td><td>47.2±0.3</td><td>49.6±0.3</td><td>·</td><td>=</td></tr><tr><td>Node2vec</td><td>55.6±0.0</td><td>58.1±0.0</td><td>-</td><td>-</td></tr><tr><td>BGRL (1 epoch)</td><td>59.3±0.5</td><td>62.1±0.3</td><td>14,057MB</td><td>26h28m</td></tr><tr><td>GBT(1 epoch)</td><td>58.9±0.4</td><td>61.5±0.5</td><td>13,185MB</td><td>24h38m</td></tr><tr><td>GGD(1 epoch)</td><td>60.2±0.3</td><td>63.5±0.5</td><td>4,105MBl68.9% 9h15ml2.7×</td><td></td></tr></table>
+
+With the corruption technique, negative samples in the negative group are generated with incorrect edges. Thus, by discriminating the positive group (i.e., nodes generated with ground truth edges) and the negative group, we conjecture the model can distil valuable signals by learning how to identify nodes generated with correct topology and output effective node embeddings. To provide explanation to this, we present the theoretical analysis of group discrimination in the following section.
+
+# 6.1.1 Theoretical Analysis of Group Discrimination
+
+Group discrimination is learning to avoid making ‘mistakes’ (i.e., bias the encoder towards avoiding mistaken samples). To explain this point, we first present Theorem 1 and then provide an intuitive explanation for group discrimination.
+
+![](images/3734132db1045b5ec7bbf7c9dacdc5503ab585b756c7fe339d5873634c35c1d5.jpg)  
+Figure 5: Corruption technique in DGI and MVGRL.
+
+Theorem 1 Given a graph G, a corrupted   
+graph ${ \widetilde { \mathsf { S } } } ,$ , and a encoding network $g ( \cdot )$ , we consider the distribution of positive embeddings $g ( \mathcal { G } )$ as $P _ { p o s }$ and negative embeddings $g ( \tilde { \mathcal { G } } )$ as $P _ { n e g }$ . Optimising the group discrimination loss is equivalent to maximising the Jensen-Shannon divergence between $P _ { p o s }$ and $P _ { n e g }$ .
+
+The proof for Theorem 1 is presented in Appendix A.2. From the theorem above, we can see maximising the group discrimination loss $\mathcal { L }$ is the same as maximising $J S ( P _ { p o s } \parallel P _ { n e g } )$ , where $J S$ represents the Jenson-Shannon divergence. Thus, by optimising the loss $\mathcal { L }$ , $P _ { p o s }$ and $P _ { n e g }$ tend to be separated. As a result, group discrimination is intuitively learning to avoid making ‘mistakes’ (i.e., bias the encoder towards avoiding mistaken samples) as shown in Figure 6. This is because by separating $P _ { p o s }$ and $P _ { n e g }$ , $P _ { p o s }$ can gradually become similar to $P _ { o p t i m a l }$ , the optimal distribution for node embeddings. As $P _ { o p t i m a l }$ , is disjoint with $P _ { n e g }$ , if the generated embeddings can avoid being similar to out-of-distribution samples, i.e., negative samples, it can be ideally closer to $P _ { o p t i m a l }$ . Therefore, the trained model can improve the quality of generated node embeddings for node samples.
+
+# 7 Future Work
+
+In this paper, we have introduced a new self-supervised GRL paradigm: Group Discrimination, which achieves the same level of performance as GCL methods with much less resource consumption (i.e., training time and memory). Some limitations of this work are we still have not explored some questions for GD. For example, can we extend the current binary Group Discrimination scheme (i.e., classifying nodes generated with different topology) to discrimination among multiple groups? Are there any other corruption tech
+
+![](images/3dcd4dfa5eb1418c564634e60ad5c8f101c15fec5f400327bbc709da259065ba.jpg)  
+Figure 6: $P _ { o p t i m a l }$ is the optimal distribution for node embeddings, $P _ { p o s }$ is the distribution of positive samples, $P _ { n e g }$ is the distribution of negative samples, blue nodes represent negative samples, and red nodes are samples in the optimal distribution. At the beginning, $P _ { p o s }$ is overlapped with $P _ { n e g }$ . Then, $P _ { p o s }$ is gradually separated from $P _ { n e g }$ and ideally become closer to $P _ { o p t i m a l }$ .
+
+nique to create a more difficult negative group for discrimination? More importantly, with the extremely efficient property, GD has the potential to be deployed to various real-world applications, e.g., recommendation systems, which have limited labelling information and desire fast computation with limited resources.
+
+# Acknowledgments and Disclosure of Funding
+
+This research was partially supported by an Australian Research Council (ARC) Future Fellowship (FT210100097).
+
+This work is supported in part by NSF under grants III-1763325, III-1909323, III-2106758, and SaTC-1930941.
+
+# References
+
+[1] Ming Jin, Yizhen Zheng, Yuan-Fang Li, Chen Gong, Chuan Zhou, and Shirui Pan. Multi-scale contrastive siamese networks for self-supervised graph representation learning. IJCAI, 2021.   
+[2] Yue Tan, Guodong Long, Jie Ma, Lu Liu, Tianyi Zhou, and Jing Jiang. Federated learning from pre-trained models: A contrastive learning approach. In First Workshop on Pre-training: Perspectives, Pitfalls, and Paths Forward at ICML 2022.   
+[3] Yue Tan, Guodong Long, Lu Liu, Tianyi Zhou, Qinghua Lu, Jing Jiang, and Chengqi Zhang. Fedproto: Federated prototype learning across heterogeneous clients. In AAAI Conference on Artificial Intelligence, volume 1, page 3, 2022.   
+[4] He Zhang, Bang Wu, Xingliang Yuan, Shirui Pan, Hanghang Tong, and Jian Pei. Trustworthy graph neural networks: Aspects, methods and trends. arXiv preprint arXiv:2205.07424, 2022.   
+[5] He Zhang, Bang Wu, Xiangwen Yang, Chuan Zhou, Shuo Wang, Xingliang Yuan, and Shirui Pan. Projective ranking: A transferable evasion attack method on graph neural networks. In CIKM, 2021.   
+[6] Ming Jin, Yuan-Fang Li, and Shirui Pan. Neural temporal walks: Motif-aware representation learning on continuous-time dynamic graphs. In Advances in Neural Information Processing Systems, 2022.   
+[7] Ming Jin, Yu Zheng, Yuan-Fang Li, Siheng Chen, Bin Yang, and Shirui Pan. Multivariate time series forecasting with dynamic graph neural odes. arXiv preprint arXiv:2202.08408, 2022.   
+[8] Yixin Liu, Zhao Li, Shirui Pan, Chen Gong, Chuan Zhou, and George Karypis. Anomaly detection on attributed networks via contrastive self-supervised learning. TNNLS, 2021.   
+[9] Yizhen Zheng, Vincent Lee, Zonghan Wu, and Shirui Pan. Heterogeneous graph attention network for small and medium-sized enterprises bankruptcy prediction. In PAKDD, pages 140–151. Springer, 2021.   
+[10] Petar Velickovi ˇ c, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon Hjelm. ´ Deep graph infomax. ICLR, 2019.   
+[11] Kaveh Hassani and Amir Hosein Khasahmadi. Contrastive multi-view representation learning on graphs. In ICML, pages 4116–4126. PMLR, 2020.   
+[12] Zhen Peng, Wenbing Huang, Minnan Luo, Qinghua Zheng, Yu Rong, Tingyang Xu, and Junzhou Huang. Graph representation learning via graphical mutual information maximization. In WWW, pages 259–270, 2020.   
+[13] Yanqiao Zhu, Yichen Xu, Feng Yu, Qiang Liu, Shu Wu, and Liang Wang. Deep graph contrastive representation learning. ICML Workshop on Graph Representation Learning and Beyond, 2020.   
+[14] Piotr Bielak, Tomasz Kajdanowicz, and Nitesh V Chawla. Graph barlow twins: A self-supervised representation learning framework for graphs. arXiv preprint arXiv:2106.02466, 2021.   
+[15] Shantanu Thakoor, Corentin Tallec, Mohammad Gheshlaghi Azar, Rémi Munos, Petar Velickovi ˇ c, and ´ Michal Valko. Bootstrapped representation learning on graphs. ICLR2021, 2021.   
+[16] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. NIPS, 2020.   
+[17] Jure Zbontar, Li Jing, Ishan Misra, Yann LeCun, and Stéphane Deny. Barlow twins: Self-supervised learning via redundancy reduction. In ICML, pages 12310–12320, 2021.   
+[18] Yuning You, Tianlong Chen, Yongduo Sui, Ting Chen, Zhangyang Wang, and Yang Shen. Graph contrastive learning with augmentations. NIPS, 33:5812–5823, 2020.   
+[19] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. ICLR, 2017.   
+[20] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. ´ Graph attention networks. ICLR, 2018.   
+[21] Yizhen Zheng, Ming Jin, Shirui Pan, Yuan-Fang Li, Hao Peng, Ming Li, and Zhao Li. Towards graph self-supervised learning with contrastive adjusted zooming. arXiv preprint arXiv:2111.10698, 2021.   
+[22] Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying graph convolutional networks. In ICML, pages 6861–6871. PMLR, 2019.   
+[23] William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NIPS, pages 1025–1035, 2017.   
+[24] Wei-Lin Chiang, Xuanqing Liu, Si Si, Yang Li, Samy Bengio, and Cho-Jui Hsieh. Cluster-gcn: An efficient algorithm for training deep and large graph convolutional networks. In KDD, pages 257–266, 2019.   
+[25] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. ICLR, 2019.   
+[26] Aleksandar Bojchevski, Johannes Klicpera, Bryan Perozzi, Amol Kapoor, Martin Blais, Benedek Rózemberczki, Michal Lukasik, and Stephan Günnemann. Scaling graph neural networks with approximate pagerank. In KDD, pages 2464–2473, 2020.   
+[27] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.   
+[28] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. arXiv preprint arXiv:1811.05868, 2018.   
+[29] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. NIPS, 2020.   
+[30] Sheng Wan, Shirui Pan, Jian Yang, and Chen Gong. Contrastive and generative graph convolutional networks for graph-based semi-supervised learning. AAAI, 2020.   
+[31] Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In ICML, pages 40–48. PMLR, 2016.   
+[32] Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In KDD, pages 855–864, 2016.   
+[33] Behzad Kamgar-Parsi, Behrooz Kamgar-Parsi, and Menashe Brosh. Distribution and moments of the weighted sum of uniforms random variables, with applications in reducing monte carlo simulations. Journal of Statistical Computation and Simulation, 52(4):399–414, 1995.   
+[34] Jean Daunizeau. Semi-analytical approximations to statistical moments of sigmoid and softmax mappings of normal variables. arXiv preprint arXiv:1703.00091, 2017.   
+[35] 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.

parse/dev/_h2FKc6E_YV/_h2FKc6E_YV_content_list.json

@@ -0,0 +1,1303 @@
+[
+    {
+        "type": "text",
+        "text": "Rethinking and Scaling Up Graph Contrastive Learning: An Extremely Efficient Approach with Group Discrimination ",
+        "text_level": 1,
+        "bbox": [
+            200,
+            122,
+            797,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yizhen Zheng1, Shirui $\\mathbf { P a n } ^ { 2 }$ ∗, Vincent CS Lee1, Yu Zheng3, Phillip S. $\\mathbf { V } \\mathbf { u } ^ { 4 }$ ,   \n1Monash University, 2Griffith University, 3La Trobe University, 4 University of Illinons at Chicago   \nyizhen.zheng1@monash.edu, s.pan@griffth.edu.au, vincent.cs.lee@monash.edu yu.zheng@latrobe.edu.au, psyu@uic.edu ",
+        "bbox": [
+            186,
+            250,
+            831,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            343,
+            535,
+            359
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph contrastive learning (GCL) alleviates the heavy reliance on label information for graph representation learning (GRL) via self-supervised learning schemes. The core idea is to learn by maximising mutual information for similar instances, which requires similarity computation between two node instances. However, GCL is inefficient in both time and memory consumption. In addition, GCL normally requires a large number of training epochs to be well-trained on largescale datasets. Inspired by an observation of a technical defect (i.e., inappropriate usage of Sigmoid function) commonly used in two representative GCL works, DGI and MVGRL, we revisit GCL and introduce a new learning paradigm for self-supervised graph representation learning, namely, Group Discrimination (GD), and propose a novel GD-based method called Graph Group Discrimination (GGD). Instead of similarity computation, GGD directly discriminates two groups of node samples with a very simple binary cross-entropy loss. In addition, GGD requires much fewer training epochs to obtain competitive performance compared with GCL methods on large-scale datasets. These two advantages endow GGD with very efficient property. Extensive experiments show that GGD outperforms state-of-theart self-supervised methods on eight datasets. In particular, GGD can be trained in 0.18 seconds (6.44 seconds including data preprocessing) on ogbn-arxiv, which is orders of magnitude $^ { ( 1 0 , 0 0 0 + ) }$ faster than GCL baselines while consuming much less memory. Trained with 9 hours on ogbn-papers100M with billion edges, GGD outperforms its GCL counterparts in both accuracy and efficiency. ",
+        "bbox": [
+            233,
+            375,
+            766,
+            664
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            688,
+            310,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs) have been widely-adopted in learning representations for graphstructured data. By utilising message-passing over the topology of a graph, GNNs can learn effective low-dimensional node embeddings, which can be used for a variety of downstream tasks such as node classification [1]. GNNs have been further applied in diverse domains, e.g., federated learning [2, 3], trustworthy systems [4, 5], dynamic graphs [6, 7] and anomaly detection [8, 9]. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            790
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, many GNNs adopt a supervised learning manner to train models with label information, which is expensive and labour-intensive to collect in real-world. To address this issue, a few studies (e.g., DGI [10], MVGRL [11], GMI [12], and GRACE [13]) borrow the idea of contrastive learning from computer vision (CV), and introduce graph contrastive learning (GCL) methods for selfsupervised GRL. The core idea of these methods is to maximise the mutual information (MI) between an anchor node and its positive counterparts, sharing similar semantic information while doing the opposite for negative counterparts as shown in Figure 1(a). Nonetheless, such a scheme relies on similarity calculation in contrastive loss computation. Additionally, GCL normally requires a large number of training epochs to be well-trained on large-scale datasets. Thus, when the size of the dataset is large, these methods require a significant amount of time and resources to be well-trained. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            826,
+            147
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Though a few GCL works attempt to improve graph contrastive learning with specially designed schemes, e.g., BGRL [15] and GBT [14], they are still inefficient and require high time consumption for model training. Inspired by BYOL [16], BGRL [15] adopts a bootstrapping scheme and remove negative node pairs. It only contrasts a node from the online network (i.e., updated with gradient) to its corresponding embedding from the target network (i.e., updated momentumly with stop gradient). Based on Barlow-Twins [17], ",
+        "bbox": [
+            174,
+            167,
+            433,
+            359
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/95495bd797059e0d73a939f5afdde8d9b4ab6a0077dd735aea28b14bb0b91a6a.jpg",
+        "image_caption": [
+            "Figure 1: The left subfigure shows the GCL learning scheme. Red line indicates MI maximisation between two nodes, each of which $\\in \\mathbb { R } ^ { 1 \\times D }$ , while blue line indicates the opposite operation. The right subfigure presents Group Discrimination. It discriminates positive and negative node samples, each of which ∈ R1×1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            459,
+            161,
+            825,
+            261
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "GBT [14] borrows the idea of redundancy-reduction principle and utilises a cross-correlation-based loss to build contrastiveness between embedding dimensions. ",
+        "bbox": [
+            173,
+            361,
+            821,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To boost training efficiency of self-supervised GRL, inspired by an observation of a technical defect (i.e., inappropriate application of Sigmoid function) in two representative GCL studies, we introduce a novel learning paradigm, namely, Group Discrimination (GD). Instead of similarity computation, GD directly discriminates a group of positive nodes from a group of negative nodes, as shown in Figure 1(b). Specifically, GD defines node samples generated with original graph as the positive group, while node samples obtained with corrupted topology are regarded as the negative group. Then, GD trains the model by classifying these node samples into the correct group with a very simple binary cross-entropy loss. By doing so, the model can extract valuable self-supervised signals from learning the edge distribution of a graph. Com",
+        "bbox": [
+            174,
+            393,
+            483,
+            642
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Training time in seconds comparison between GGD and GBT [14] (i.e., the most efficient GCL baseline as shown in section 5.1) on ogbnarxiv. Number in brackets means the hidden size. ‘Pre’, ‘Tr’ and ‘Epo’ indicate preprocessing time, training time per epoch, and the number of epochs for training GNNs. ‘Total(E)’ and ‘Total(T)’ are total end-to-end training time (i.e., including preprocessing), which equals to $( { \\mathrm { P r e } } + { \\mathrm { E p o } } \\times { \\mathrm { T r } } )$ and total training time, which is $( { \\mathrm { E p o } } \\times { \\mathrm { T r } } )$ . ‘Imp(E)’ and $\\mathrm { \\cdot { I m p ( T ) } } ^ { \\mathrm { , } }$ indicate how many times GGD improve on ‘Total(E)’ and ‘Total(T)’. ‘Acc’ is averaged accuracy result on test set over five runs. ",
+        "bbox": [
+            498,
+            397,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/09187e71b5999d88d06f5dc891efbb9ff2981f5acf665de2860b46d70047b32c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Pre</td><td>Tr</td><td>Epo</td><td colspan=\"2\">Total(E) Imp(E)</td><td colspan=\"2\">Total(T)Imp(T)</td><td>Acc</td></tr><tr><td>GBT(256)</td><td>5.52</td><td>6.47</td><td>300</td><td>1,946.52</td><td>-</td><td>1,941.00</td><td>=</td><td>70.1</td></tr><tr><td>GGD(256)</td><td>6.26 0.18</td><td></td><td>1</td><td>6.44</td><td>302.25×</td><td>0.18</td><td>10,783.33x</td><td>70.3</td></tr><tr><td>GGD(1,500)</td><td></td><td>6.260.95</td><td>1</td><td>7.21</td><td>269.96×</td><td>0.95</td><td>2.043.16×</td><td>71.6</td></tr></table>",
+        "bbox": [
+            500,
+            585,
+            823,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "pared with GCL, GD enjoys numerous merits including extremely fast training, fast convergence (e.g., 1 epoch to be well-trained on large-scale datasets), and high scalability while achieving SOTA performance with existing GCL approaches. ",
+        "bbox": [
+            176,
+            643,
+            823,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Using GD as backbone, we design a new self-supervised GRL model with the Siamese structure called Graph Group Discrimination (GGD). Firstly, we can optionally augment a given graph with augmentation techniques, e.g., feature and edge dropout. Then, the augmented graph is fed into a GNN encoder and a projector to obtain embeddings for the positive group. After that, the augmented feature is corrupted with node shuffling (i.e., disarranging the order of nodes in the feature matrix) to disrupt the topology of a graph and input to the same network for obtaining embeddings of the opposing group. Finally, the model is trained by discriminating these two groups of node samples. The contributions of this paper are three-fold: 1) We re-examine existing GCL approaches (e.g., DGI [10] and MVGRL [11]), and we introduce a novel and efficient self-supervised GRL paradigm, namely, Group Discrimination (GD). 2) Based on GD, we propose a new self-supervised GRL model, GGD, which is fast in training and convergence, and possess high scalability. 3) We conduct extensive experiments on eight datasets, including an extremely large dataset, ogbn-papers100M with billion edges. The experiment results show that our proposed method reaches state-of-the-art performance while consuming much less time and memory than baselines, e.g., $\\mathbf { 1 0 7 8 3 \\times }$ faster than the most efficient GCL baseline with its best selected epochs number [14], as shown in Table 1. ",
+        "bbox": [
+            173,
+            690,
+            826,
+            897
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Rethinking Representative GCL Methods ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we analyse a technical defect observed in two representative GCL methods, DGI [10] and MVGRL [11]. Based on the technical defect, we show that mutual information maximisation behind these two approaches is not the contributed factor to contrastive learning, but a new paradigm, group discrimination. Finally, from the analysis, we provide the definition of this new concept. ",
+        "bbox": [
+            174,
+            121,
+            485,
+            244
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Rethinking GCL Methods ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            262,
+            393,
+            277
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "DGI [10] is the first work introducing contrastive learning into GRL. However, due to a technical defect observed in their official opensource code, we found it is essentially not working as the authors thought (i.e., learning via MI interaction). ",
+        "bbox": [
+            174,
+            289,
+            485,
+            343
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e005a7bfab03de24a46df553ee290e45d447140dd4a7b74c7ad6162d90db0cd4.jpg",
+        "image_caption": [
+            "Figure 2: The architecture of DGI. Cubes indicate node embeddings. Red and blue lines represent MI maximisation and minimisation, respectively. G and $\\widetilde { \\mathcal { G } }$ denote the original graph and the corrupted graph. s is the summary vector. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            568,
+            126,
+            751,
+            241
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            344,
+            566,
+            358
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Constant Summary Vector. As shown in Figure 2, the original idea of DGI is to maximise the MI (i.e., the red line) between a node $a$ and the summary vector s, which is obtained by averaging all node embeddings in a graph G. Also, to regularise the model training, DGI corrupts G by shuffling the node order of the input feature matrix to get G˜. Then, generated embeddings of $\\widetilde { \\mathcal { G } }$ serve as negative samples, which are pulled apart from the summary vector s via MI minimisation. ",
+        "bbox": [
+            173,
+            367,
+            825,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Nonetheless, in the implementation of DGI, a Sigmoid function is inappropriately applied on the summary vector generated from a GNN whose weight is initialised with Xavier initialisation. As a result, elements in the summary vector are very close to the same value. We have validated this finding on three datasets, Cora, CiteSeer and PubMed. The experiment result is shown in Table 2, which shows that summary vec",
+        "bbox": [
+            174,
+            445,
+            421,
+            597
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/1c53f5c9f4c82377e93459c9679325af278802990f350c320232c137a8b041a2.jpg",
+        "table_caption": [
+            "Table 2: Summary vector statistics on three datasets with different activation functions including ReLU, LeakyReLU (i.e., LReLU shown below), PReLU, and Sigmoid. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Activation</td><td>Statistics</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td></tr><tr><td rowspan=\"3\">ReLU/LReLU/PReLU</td><td>Mean</td><td>0.50</td><td>0.50</td><td>0.50</td></tr><tr><td>Std</td><td>1.3e-03</td><td>1.0e-04</td><td>4.0e-04</td></tr><tr><td>Range</td><td>1.4e-03</td><td>8.0e-04</td><td>1.5e-03</td></tr><tr><td rowspan=\"3\">Sigmoid</td><td>Mean</td><td>0.62</td><td>0.62</td><td>0.62</td></tr><tr><td>Std</td><td>5.4e-05</td><td>2.9e-05</td><td>6.6e-05</td></tr><tr><td>Range</td><td>3.6e-03</td><td>3.0e-03</td><td>3.2e-03</td></tr></table>",
+        "bbox": [
+            433,
+            502,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "tors in all datasets are approximately a constant vector $\\epsilon I$ , where $\\epsilon$ is a scalar and $\\pmb { I }$ is an all-ones vector (i.e., $\\scriptstyle \\epsilon = 0 . 5 0$ with ReLU/LReLU/PReLU and $\\epsilon { = } 0 . 6 2$ with Sigmoid as non-linear activation in these datasets). ",
+        "bbox": [
+            176,
+            598,
+            825,
+            638
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To theoretically explain this phenomenon, we present the proposition below: ",
+        "bbox": [
+            174,
+            645,
+            529,
+            672
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/4664242852fcb43509c3a7a7e40b566f2ba8099606efb8535eb560f5db440d43.jpg",
+        "table_caption": [
+            "Table 3: The experiment result on three datasets with changing value from 0 to 1.0 for the summary vector. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>0</td><td>0.2</td><td>0.4</td><td>0.6</td><td>0.8</td><td>1.0</td></tr><tr><td>Cora</td><td></td><td></td><td></td><td></td><td>70.3±0.7 82.4±0.2 82.3±0.3 82.5±0.4 82.3±0.3 82.5±0.1</td><td></td></tr><tr><td>CiteSeer</td><td></td><td></td><td></td><td></td><td>61.8±0.8 71.7±0.6 71.9±0.7 71.6±0.9 71.7±1.0 71.6±0.8</td><td></td></tr><tr><td>PubMed</td><td>68.3±1.5 77.8±0.5 77.9±0.8 77.7±0.9 77.4±1.1 77.2±0.9</td><td></td><td></td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            544,
+            694,
+            843,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1 Given $\\mathcal { G } = \\{ \\mathbf { X } \\in \\mathbb { R } ^ { N \\times D } , \\mathbf { A } \\in \\mathbb { R } ^ { N \\times N } \\} ,$ and a GCN encoder $g ( \\cdot )$ initialised with Xavier initialisation, we can obtain its embedding $\\mathbf { H } = \\sigma ( g ( \\mathcal { G } ) )$ , where $\\sigma ( \\cdot )$ is a non-linear activation function. By applying the sigmoid function $\\sigma _ { s i g } ( \\cdot )$ to the summary vector s (i.e., the average row vector of H), values in $\\sigma _ { s i g } ( \\mathbf { s } )$ approximately become 0.5 with ReLU/LReLU/PReLU or 0.62 with Sigmoid as non-linear activation of $g ( \\cdot )$ at the initialisation stage. ",
+        "bbox": [
+            173,
+            684,
+            531,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            741,
+            830,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Based on this proposition, we can see these summary vectors can lose variance and become a constant vector at the initialisation stage. Based on Table 2, we can see the constant in the summary vector remain unchanged, and the information loss still occurs even if the GNN encoder is trained. Thus, we conjecture the training process won’t affect the constant value much in the summary vector of DGI. The proof for the proposition is presented in Appendix A.1. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            863
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the effect of $\\epsilon$ to constant summary vector, we vary the scalar $\\epsilon$ (from 0 to 1 increment by 0.2) to change the constant summary vector and report the model performance (i.e., averaged accuracy on five runs) in Table 3. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "From this table, we can see, except for 0, the model performance is trivially affected by $\\epsilon$ for constant summary vector. When the summary vector is set to 0, the model performance plummets because node embeddings become all 0 when multiplying with such vector and the model converges to the trivial solution. As the summary vector only has a trivial effect on model training, the hypothesis of DGI [10] on learning via contrastiveness between anchor nodes and the summary instance does not hold, which raises a question to be investigated: What truly leads to the success of DGI? ",
+        "bbox": [
+            173,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Simplifying DGI. To answer the question, we predigest the objective function proposed in DGI (i.e., maximising the MI between $\\mathbf { h } _ { i }$ and the summary vector s) by using an all-ones vector as the summary vector s (i.e., setting $\\mathbf { s } = \\epsilon \\pmb { I } = \\pmb { I }$ ) and simplifying the discriminator $\\mathcal { D } ( \\cdot )$ (i.e., removing the learnable weight matrix). Then, we rewrite the objective function to the following form: ",
+        "bbox": [
+            174,
+            180,
+            825,
+            237
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/667cb13b74861b30c0bd5b64b07b24cfd431ddc7f8cbc0ebb0ca147b0f13d3a9.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\mathcal { L } _ { D G I } = \\frac { 1 } { 2 N } ( \\sum _ { i = 1 } ^ { N } \\log \\mathcal { D } ( \\mathbf { h } _ { i } , \\mathbf { s } ) + \\log ( 1 - \\mathcal { D } ( \\tilde { \\mathbf { h } } _ { i } , \\mathbf { s } ) ) ) , } \\\\ { \\displaystyle \\qquad = \\frac { 1 } { 2 N } ( \\sum _ { i = 1 } ^ { N } \\log ( \\mathbf { h } _ { i } \\cdot \\mathbf { s } ) + \\log ( 1 - \\tilde { \\mathbf { h } } _ { i } \\cdot \\mathbf { s } ) ) ) , } \\\\ { \\displaystyle \\qquad = \\frac { 1 } { 2 N } ( \\sum _ { i = 1 } ^ { N } \\log ( s u m ( \\mathbf { h } _ { i } ) ) + \\log ( 1 - s u m ( \\tilde { \\mathbf { h } } _ { i } ) ) ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            241,
+            681,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\cdot$ is the vector multiplication operation, $N$ is the number of nodes in a graph, $\\mathbf { h } _ { i } \\in \\mathbb { R } ^ { 1 \\times D }$ and $\\tilde { \\mathbf { h } } _ { i } \\in \\mathbb { R } ^ { 1 \\times D }$ are the original and corrupted embedding for node $i$ $, s u m ( \\cdot )$ is the summation function, and $\\mathcal { D } ( \\cdot )$ is a discriminator for bilinear transformation, which can be formulated as follows: ",
+        "bbox": [
+            173,
+            378,
+            825,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a3d050b07eed923d0342349122e74891d3f9436076f13c9a55491cfcfc179757.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathrm { \\bf ~ \\mathcal { D } } ( { \\bf h } _ { i } , { \\bf s } ) = \\sigma _ { s i g } ( { \\bf h } _ { i } \\cdot { \\bf W } \\cdot { \\bf s } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            428,
+            589,
+            445
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { W }$ is a learnable weight matrix and $\\sigma _ { s i g } ( \\cdot )$ is the sigmoid function. Specifically, as shown in Equation 2, by removing the weight matrix $\\mathbf { W } ,  { \\mathbf { h } } _ { i }$ is directly multiplied with s. As s is a vector containing only one, the multiplication of $\\mathbf { h } _ { i }$ and s is equivalent to summing $\\mathbf { h } _ { i }$ itself directly. From this form, we can see that the multiplication of $\\mathbf { h } _ { i }$ and the summary vector only serves as an aggregation function (i.e., summation aggregation) to aggregate $\\mathbf { h } _ { i }$ . To explore the effect of other aggregation functions, we replace the summation function in Equation 1 with other aggregation methods such as mean-, minimum-, and maximum- pooling, and present the experiment result in Appendix A.3. ",
+        "bbox": [
+            174,
+            449,
+            516,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Comparison of the original DGI and $\\mathrm { D G I } _ { B C E }$ in terms of accuracy (averaged on five runs), memory efficiency (in MB) and training time (in seconds). Number after | shows how many times have $\\mathrm { D G I } _ { B C E }$ improved on top of DGI. ",
+        "bbox": [
+            529,
+            452,
+            825,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/d692d7250a72e801953849383d6581668499883ed1c7fe51756100f3768cef49.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Experiment</td><td>Method</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td></tr><tr><td>Accuracy</td><td>DGI</td><td>81.7±0.6</td><td>71.5±0.7</td><td>77.3±0.6</td></tr><tr><td></td><td>DGIBCE</td><td>82.5±0.3</td><td>71.7±0.6</td><td>77.7±0.5</td></tr><tr><td>Memory</td><td>DGI</td><td>4189MB</td><td>8199MB</td><td>11471MB</td></tr><tr><td></td><td>DGIBCE</td><td></td><td></td><td>1475MBl64.8%1587MBl80.6%1629MBl85.8%</td></tr><tr><td>Time</td><td>DGI</td><td>0.085s</td><td>0.134s</td><td>0.158s</td></tr><tr><td></td><td>DGIBCE</td><td>0.010sl8.5×</td><td>0.021sl6.4×</td><td>0.015sl10.5×</td></tr></table>",
+        "bbox": [
+            532,
+            544,
+            826,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on Equation 1, we can rewrite it to a very simple binary cross entropy loss if we also include corrupted nodes as data samples and setting ${ \\hat { y } } _ { i } = a g g ( \\mathbf { h } _ { i } )$ , where $a g g ( \\cdot )$ stands for aggregation: ",
+        "bbox": [
+            174,
+            648,
+            823,
+            678
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6aa7a031f94dfff64078c3d16f959d44f76929dcebbbe3b9a74e4d6d32569a96.jpg",
+        "text": "$$\n\\mathcal { L } _ { B C E } = - \\frac { 1 } { 2 N } ( \\sum _ { i = 1 } ^ { 2 N } y _ { i } \\log \\hat { y } _ { i } + ( 1 - y _ { i } ) \\log ( 1 - \\hat { y } _ { i } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            683,
+            676,
+            726
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { i } \\in \\mathbb { R } ^ { 1 \\times 1 }$ means the indicator for node $i$ (i.e., if node $i$ is corrupted, $y _ { i }$ is 0, otherwise it is 1), and $\\hat { y } _ { i } \\in \\mathbb { R } ^ { 1 \\times 1 }$ represents the prediction for a node sample $i$ . As we include corrupted nodes as data samples, the size of nodes to be processed is doubled to $2 N$ (i.e., the number of corrupted nodes is equal to the number of original nodes). From the equation above, we can easily observe that what DGI truly does is discriminate between a group of nodes generated with correct topology and nodes generated with corrupted topology, as shown in Figure 1. We name this self-supervised learning paradigm \"Group Discrimination\". To validate the effectiveness of this paradigm, we replace the original DGI loss with Equation 3, namely, $\\mathrm { D G I } _ { B C E }$ and compare it with DGI on three datasets in terms of training time, memory efficiency and model performance as shown in Table 4. Here, $\\mathrm { D G I } _ { B C E }$ adopts the same parameter setting as DGI. From this table, we can observe $\\mathrm { D G I } _ { B C E }$ dramatically improves DGI in both memory and time efficiency while it slightly enhances the model performance of DGI. This may be contributed to the removal of multiplication operations between node pairs, which eases the burden of computation and memory consumption. ",
+        "bbox": [
+            173,
+            731,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to DGI, the same technical defect is observed in MVGRL [11], which makes it become a GD-based method. Extended on DGI, MVGRL [11] incorporates diffusion augmentation to inject additional global information into model training, which enhances the model performance. The detailed analysis for MVGRL is presented in Appendix A.4. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2 Definition of Group Discrimination ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            162,
+            457,
+            178
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As mentioned above, Group Discrimination is a self-supervised GRL paradigm, which learns by discriminating different groups of node samples. Specifically, the paradigm assigns different indicators to different groups of node samples. For example, for binary group discrimination, one group is considered as the positive group with class 1 as its indicator, whereas the other group is the negative group, having its indicator assigned as 0. Given a graph G, the positive group usually includes node samples generated with the original graph G or its augmented views (i.e., similar graph instances of G created by augmentation). In contrast, the opposing group contains negative samples obtained by corrupting G, e.g., changing its topology structure. ",
+        "bbox": [
+            173,
+            189,
+            825,
+            300
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on our theoretical analysis, group discrimination is learning to avoid making ‘mistakes’ (i.e., bias the encoder towards avoiding mistaken samples), thus improving the quality of generated embeddings. The analysis and an intuitive explanation are presented in Section 6.1.1 and A.2.1. ",
+        "bbox": [
+            176,
+            306,
+            825,
+            348
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            313,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first define unsupervised node representation learning and then present the architecture of GGD, which extends $\\mathbf { D G I } _ { B C E }$ with additional augmentation, the projector and embedding reinforcement to reach better model performance. Given a graph G with attributes $\\mathbf { X } \\in \\mathbb { R } ^ { N \\times D }$ , where $N$ is the number of nodes in G, and $D$ is the number of dimensions of $\\mathbf { X }$ , our aim is to train a GNN encoder without the reliance on labelling information. With the trained encoder, taking G and $\\mathbf { X }$ as input, it can output learned representations $\\mathbf { H } \\in \\mathbb { R } ^ { N \\times D ^ { \\prime } }$ , where $D ^ { \\prime }$ is the predefined hidden dimension. H can then be used in many downstream tasks such as node classification. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/35924d1789fec858cdd0bc17c036fbafa43902aba9cf673742249a05da6a4c9a.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            520,
+            818,
+            669
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 3: The architecture of GGD. Given a graph G with a feature matrix $\\mathbf { X }$ , we can optionally apply augmentation on them to generate $\\hat { \\mathcal G }$ and $\\hat { \\mathbf X }$ . Then, we corrupt $\\hat { \\mathbf { X } }$ and $\\hat { \\mathcal G }$ to obtain $\\tilde { \\mathbf { X } }$ and G˜. Taking $\\dot { \\hat { \\mathbf { X } } }$ and $\\hat { \\mathcal G }$ as input to the encoder and the projector, i.e., a multilayer perceptron, positive node samples can be obtained. Similarly, $\\tilde { \\mathbf { X } }$ and $\\tilde { \\mathcal { G } }$ are fed to the same encoder and projector to generate negative samples. The generated embeddings are aggregated to get predictions for the group discrimination task. This process will be iteratively conducted until reaching the predefined training epochs. ",
+        "bbox": [
+            173,
+            684,
+            825,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Graph Group Discrimination ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            416,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on the proposed self-supervised GRL paradigm, group discrimination, we have designed a novel method, namely GGD, to learn node representations using a siamese network structure and a BCE loss. The architecture of GGD is presented in Figure 3. The framework mainly consists of four components: augmentation, corruption, a siamese GNN network, and group discrimination. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Augmentation. With a given graph G and feature matrix $\\mathbf { X }$ , optionally, we can augment it with augmentation techniques such as edge and feature dropout to create $\\hat { \\mathcal G }$ and $\\hat { \\mathbf X }$ . In practice, we follow the augmentation proposed in GraphCL [18]. Specifically, edge dropout removes a predefined fraction of edges, while we use node dropout to mask a predefined proportion of feature dimension, i.e., assigning 0 to replace values in randomly selected dimensions. This step is optional in implementation. ",
+        "bbox": [
+            173,
+            881,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Notably, the motivation of using augmentation in our framework is distinct from contrastive learning methods. In our study, augmentation is used to increase the difficulty of the self-supervised training tasks. With augmentation, $\\hat { \\mathcal G }$ and $\\hat { \\mathbf { X } }$ change in every training iteration, which forces the model to lessen the dependence on the fixed pattern (i.e., unchanged edge and feature distribution) in a monotonous graph. However, in contrastive learning, augmentation creates augmented views sharing similar semantic information for building contrastiveness. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            226
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Corruption. $\\hat { \\mathcal G }$ and $\\hat { \\mathbf X }$ are then corrupted to build $\\tilde { \\mathcal { G } }$ and $\\tilde { \\mathbf { X } }$ for the generation of node embeddings in the negative group. We adopt the same corruption technique used in DGI [10] and MVGRL [11] (as shown in Figure 5). The corruption technique devastates the topology structure of $\\hat { \\mathcal G }$ by randomly changing the order of nodes in $\\hat { \\mathbf { X } }$ . The corrupted $\\tilde { \\mathbf { X } }$ and $\\tilde { \\mathcal { G } }$ can be used for producing node representations with incorrect network connections. ",
+        "bbox": [
+            174,
+            232,
+            825,
+            308
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Siamese GNN. We have designed a siamese GNN network to output node representations given a graph and its attribute. The siamese GNN network is made up of two components, which are a GNN encoder and a projector. The backbone GNN encoder is replaceable with a variety of choices of GNNs, e.g., GCN [19] and GAT [20]. In our work, we adopt GCN as the backbone. The projector is a multi-layer perceptron network, whose number of layers can be adjusted. When generating node embeddings of the positive group, the Siamese network takes $\\hat { \\mathcal G }$ and $\\hat { \\mathbf { X } }$ as input. Using the same encoder and projector, the Siamese network output the negative group with $\\bar { \\mathfrak { G } }$ and $\\tilde { \\mathbf { X } }$ . These two groups of node embeddings are considered as a collection of data samples with a size of $2 N$ for discrimination. Before conducting group discrimination, in the “aggregation” phase, all data samples are aggregated with the same aggregation technique, e.g., sum-, mean-, and linear aggregation. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            457
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Group Discrimination. In the group discrimination process, we adopt a very simple binary cross entropy (BCE) loss to discriminate two groups of node samples as shown in Equation 3. In our implementation, $y _ { i }$ is 0 and 1 for node embeddings in negative and positive groups. During model training, the model is optimised by categorising node embeddings in the collection of data samples into their corresponding class correctly. The loss is computed by comparing the prediction of a node $i$ , i.e., a scalar, with its indicator $y _ { i }$ . With the ease of BCE loss computation, the training process of GGD is very fast and memory efficient. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            560
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 Model Inference ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            326,
+            590
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "During training, the model is optimised via loss minimisation with Equation 3. The time complexity analysis of GGD is provided in Appendix A.5. In the inference phase, we freeze the trained GNN encoder $g _ { \\theta }$ and obtain node embeddings $\\mathbf { H } _ { \\theta }$ with the input G. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            643
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inspired by MVGRL [11], which strengthens the output embeddings by including additional global information, we adopt a conceptually similar embedding reinforcement approach. Specifically, they obtain the final embeddings by summing up embeddings from two views: the original view comprising local information and the diffused view with global information. This operation reinforces the final embeddings and leads to model performance improvement. Nonetheless, graph diffusion impairs the scalability of a model [21] and hence cannot be directly applied in our embedding generation process. To avoid the diffusion computation, we have come up with a workaround in the virtue of the power of a graph to extract global information. The power of a graph can extend the message passing scope of $\\mathbf { H } _ { \\theta }$ to n-hop neighbourhood, which encodes global information from distant neighbours. It can be formulated as follows: ",
+        "bbox": [
+            174,
+            648,
+            825,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ea1c50911d7293f36179f5fbf5fc660b97d2a026ed0f08a2806fc9b8ef42f09.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { H } _ { \\theta } ^ { g l o b a l } = \\mathbf { A } ^ { n } \\mathbf { H } _ { \\theta } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            786,
+            557,
+            806
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where Hglobal is the global embedding, and $\\mathbf { A }$ is the adjacency matrix of the graph G. It is notable that this operation can be easily decomposed with the associative property of matrix multiplication and is easy to compute. To show the easiness of such computation, we conduct an experiment showing its time consumption on various datasets in Appendix A.6. Finally, the final embedding can be achieved by $\\mathbf { H } = \\mathbf { H } _ { \\theta } ^ { g l o \\bar { b } a l } + \\mathbf { H } _ { \\theta }$ , which can be used for downstream tasks. In our experiment, we conduct node classification tasks. Following the common practice of GCL methods [10, 13, 15, 12, 17], these tasks are performed by using the final embeddings $\\mathbf { H }$ to train and test a simple logistic regression classifier. ",
+        "bbox": [
+            173,
+            810,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            321,
+            106
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs). are generalised deep neural networks for graph-structured data. GNNs mainly have two categories, spectral-based GNNs and spatial-based GNNs. Spectral GNNs attempt to use eigen-decomposition to obtain the spectral-based representation of graphs, whereas spatial GNNs focus on using spatial neighbours of nodes for message passing. Extending spectral-based methods to the spatial domain, GCN [19] utilises first-order Chebyshev polynomial filters to approximate spectral-based graph convolution. Taking the weight of spatial neighbours in consideration, GAT [20], improves GCN by introducing attention module in message passing. To decouple message passing from neural networks, SGC [22] simplifies GCN by removing non-linearity and weight matrices in graph convolution layers. However, these studies cannot handle datasets with limited or no labels. Graph contrastive learning has been recently exploited to address this issue. ",
+        "bbox": [
+            174,
+            119,
+            825,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Graph Contrastive Learning (GCL). aims to alleviate the reliance on labelling information in model training based on the concept of mutual information (MI). Specifically, GCL approaches maximise MI between instances with similar semantic information, and minimise MI between dissimilar instances. For example, DGI [10] builds contrastiveness between node embeddings and a summary vector (i.e., a graph level embedding obtained by averaging all node embeddings) with a JSD estimator. To improve DGI, MVGRL [11] and GMI [12] extends the idea of DGI by introducing multi-view contrastiveness with diffusion augmentation, and focusing on a local scope with the first-order neighbourhood, respectively. Adopting InfoNCE loss, GRACE [13] applies augmentation techniques to create two augmented views and inject contrastiveness between them. Though these GCL methods have successfully outperformed some supervised baselines in benchmark datasets, these methods suffer from significant limitations, including time-consuming training, memory inefficiency, and poor scalability. In contrast, GGD requires much less time in training and posses high scalability. ",
+        "bbox": [
+            174,
+            265,
+            825,
+            431
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Scalable GNNs. Efficiency is a bottleneck for most existing GNNs to handle large graphs. To address this challenge, there are mainly three categories of approaches: layer-wise sampling (e.g., GraphSage [23]), graph sampling methods such as Cluster-GCN [24] and GraphSAINT [25], and linear models, e.g., SGC [22] and PPRGo [26]. GraphSage [23] introduces a neighbour-sampling approach, which creates fixed-size subgraphs for each node. Underpinned by graph sampling, Cluster-GCN [24] decomposes a large-scale graph into multiple subgraphs based on clustering, while GraphSAINT [25] utilises light-weight graph samplers along with a normalisation technique for biases elimination in mini-batches. Linear models, SGC [22] and PPRGo [26], decouple graph convolution from embedding transformation (i.e., matrix multiplication with weight matrices), and leverage Personalised PageRank to encode multi-hop neighbourhood, respectively. However, all these methods only focus on supervised learning on graphs. For unsupervised/self-supervised learning settings where no labelled supervision signal is available, these frameworks are not applicable. The closest works to ours to handle large scale graph datasets under self-supervised settings are BGRL [15] and GBT [14]. They try to improve the contrastive losses by removing negative samples. However, BGRL [15] and GBT [14] still require much more time in training compared with GGD. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            643
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            662,
+            312,
+            680
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the effectiveness of our model using eight benchmark datasets of different sizes. These datasets include five small- and mediumscale datasets: Cora, CiteSeer, PubMed [27], Amazon Computers, and Amazon Photos [28], as well as large-scale datasets ogbn-arxiv, ogbnproducts and ogbn-papers100M. Notably, ogbnpapers100M is the largest dataset provided by Open Graph Benchmark[29] for node property prediction tasks. It has over 110 million nodes and 1 billion edges. The statistics of these datasets are summarised in Appendix A.7. To ",
+        "bbox": [
+            174,
+            695,
+            491,
+            881
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c68a537f876d0c74762ac7c9458f7f4e2d78f15c1ba9f08b095ecf83a88325ab.jpg",
+        "table_caption": [
+            "Table 5: Model performance of node classification on 5 datasets. X, A and Y represent feature, adjacency matrix, and labels. Best performance for each dataset is in bold. Comp and Photo refer to Amazon Computers and Amazon Photos. "
+        ],
+        "table_footnote": [
+            "ensure reproducibility, the detailed experiment settings and computing infrastructure are summarised in Appendix A.8. The source code is already open sourced2. "
+        ],
+        "table_body": "<table><tr><td>Data</td><td>Method</td><td>Cora</td><td></td><td>CiteSeer PubMed</td><td>Comp</td><td>Photo</td></tr><tr><td>X,A,Y</td><td>GCN</td><td>81.5</td><td>70.3</td><td>79.0</td><td></td><td>76.3±0.5 87.3±1.0</td></tr><tr><td>X,A,Y</td><td>GAT</td><td>83.0±0.7 72.5±0.7 79.0±0.3 79.3±1.1 86.2±1.5</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A,Y</td><td>SGC</td><td>81.0±0.0 71.9±0.1 78.9±0.0 74.4±0.1 86.4±0.0</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A,Y</td><td>CG3</td><td>83.4±0.7 73.6±0.8 80.2±0.8 79.9±0.6 89.4±0.5</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A</td><td>DGI</td><td>81.7±0.6 71.5±0.7 77.3±0.6 75.9±0.6 83.1±0.5</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A</td><td>GMI</td><td>82.7±0.2 73.0±0.3 80.1±0.2 76.8±0.1 85.1±0.1</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A</td><td>MVGRL</td><td>82.9±0.7 72.6±0.7 79.4±0.3 79.0±0.6 87.3±0.3</td><td></td><td></td><td></td><td></td></tr><tr><td>X,A</td><td>GRACE</td><td></td><td></td><td></td><td></td><td>80.0±0.4 71.7±0.6 79.5±1.1 71.8±0.4 81.8±1.0</td></tr><tr><td>X,A</td><td>GraphCL</td><td>82.5±0.2 72.8±0.3 77.5±0.2 OOM</td><td></td><td></td><td></td><td>79.5±0.4</td></tr><tr><td>X,A</td><td>BGRL</td><td></td><td></td><td></td><td></td><td>80.5±1.0 71.0±1.2 79.5±0.6 89.2±0.9 91.2±0.8</td></tr><tr><td>X,A</td><td>GBT</td><td></td><td></td><td></td><td>81.0±0.5 70.8±0.2 79.0±0.1 88.5±1.0 91.1±0.7</td><td></td></tr><tr><td>X,A</td><td>GGD</td><td></td><td></td><td></td><td>83.9±0.4 73.0±0.6 81.3±0.8 90.1±0.9 92.5±0.6</td><td></td></tr></table>",
+        "bbox": [
+            504,
+            723,
+            828,
+            858
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Evaluating on Small- and Medium-scale Datasets ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            92,
+            553,
+            106
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare GGD with ten baselines including four supervised GNNs (i.e., GCN [19], GAT [20], SGC [22], and CG3 [30]) and six GCL methods (i.e., DGI [10], GMI [12], MVGRL [11], GRACE [13], BGRL [15] and GBT [14]) on five small- and medium scale benchmark datasets. In the experiment, we follow the same data splits as [31] for Cora, CiteSeer and PubMed. For Amazon Computers and Photos, we use a random split setting, which randomly allocates $10 / 1 0 / 8 0 \\%$ of data to training/validation/test set, respectively. The model performance is measured using the averaged ",
+        "bbox": [
+            174,
+            117,
+            485,
+            296
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b476c16e836e8639f52854d89f08a71baf03d1ed917bd1daee5e44d413f72f78.jpg",
+        "table_caption": [
+            "Table 6: Comparison of training time per epoch in seconds between six GCL-based methods and GGD on five datasets. Improve means how many times are GGD faster than baselines. ‘-’ means the improvement range. "
+        ],
+        "table_footnote": [
+            "classification accuracy with five results along with standard deviations and reported in Table 5. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td><td>Comp</td><td>Photo</td></tr><tr><td>DGI</td><td>0.085</td><td>0.134</td><td>0.158</td><td>0.171</td><td>0.059</td></tr><tr><td>GMI</td><td>0.394</td><td>0.497</td><td>2.285</td><td>1.297</td><td>0.637</td></tr><tr><td>MVGRL</td><td>0.123</td><td>0.171</td><td>0.488</td><td>0.663</td><td>0.468</td></tr><tr><td>GRACE</td><td>0.056</td><td>0.092</td><td>0.893</td><td>0.546</td><td>0.203</td></tr><tr><td>GraphCL</td><td>0.073</td><td>0.085</td><td>0.123</td><td>OOM</td><td>0.188</td></tr><tr><td>BGRL</td><td>0.085</td><td>0.094</td><td>0.147</td><td>0.337</td><td>0.273</td></tr><tr><td>GBT</td><td>0.073</td><td>0.072</td><td>0.103</td><td>0.492</td><td>0.173</td></tr><tr><td>GGD</td><td>0.010</td><td>0.021</td><td>0.015</td><td>0.016</td><td>0.009</td></tr><tr><td>Improve</td><td>7.3-39.4×</td><td>3.4-23.7×</td><td>6.9-152.3×</td><td>10.7-15.3×</td><td>19.2-70.8x</td></tr></table>",
+        "bbox": [
+            500,
+            186,
+            826,
+            287
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Accuracy. From Table 5, we can observe that GGD generally outperforms all baselines in all datasets. The only exception is on CiteSeer dataset, where the semi-supervised method, CG3[30], slightly outperforms GGD, which still provides the 2nd best performance. In this experiment, we use the officially released code of GraphCL [18], BGRL [15] and GBT [14] to reproduce the result, while the other results are sourced from previous studies [30, 1]. ",
+        "bbox": [
+            174,
+            316,
+            485,
+            455
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Efficiency and Memory Consumption. GGD is ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            462,
+            483,
+            476
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7b118ef875900b3a04035ff5e1d67210f125021f0056c225d3cac942333338ba.jpg",
+        "table_caption": [
+            "Table 7: Comparison of memory consumption in MBs of six GCL baselines and GGD on five datasets. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Cora</td><td>CiteSeer</td><td>PubMed</td><td>Comp</td><td>Photo</td></tr><tr><td>DGI</td><td>4,189</td><td>8,199</td><td>11,471</td><td>7,991</td><td>4.946</td></tr><tr><td>GMI</td><td>4,527</td><td>5,467</td><td>14.697</td><td>10.655</td><td>5,219</td></tr><tr><td>MVGRL</td><td>5,381</td><td>5,429</td><td>6.619</td><td>6.645</td><td>6.645</td></tr><tr><td>GRACE</td><td>1,913</td><td>2.043</td><td>12.597</td><td>8,129</td><td>4,881</td></tr><tr><td>GraphCL</td><td>4,163</td><td>8,249</td><td>11,555</td><td>OOM</td><td>9.083</td></tr><tr><td>BGRL</td><td>1,627</td><td>1,749</td><td>2.299</td><td>5.069</td><td>3.303</td></tr><tr><td>GBT</td><td>1,651</td><td>1,799</td><td>2,461</td><td>5.037</td><td>2.641</td></tr><tr><td>GGD</td><td>1,475</td><td>1,587</td><td>1,629</td><td>1,787</td><td>1,637</td></tr><tr><td>Improve</td><td>10.7-72.6%</td><td>11.8-80.6%</td><td>27.2-85.8%</td><td>64.5-83.2%</td><td>38.0-75.4%</td></tr></table>",
+        "bbox": [
+            500,
+            362,
+            823,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "substantially more efficient than other self-supervised baselines in time and memory consumption as shown in Table 6 and Table 7. Remarkably, GGD is 19.2 times faster in Amazon Photos for training time per epoch, and consumes $6 4 . 5 \\%$ less memory in Amazon Computers for memory consumption than the most efficient baseline (i.e., GBT [14]). The dramatic boost of time and memory efficiency of GGD is contributed to the exclusion of similarity computation, which enables model training without multiplication of node embeddings. ",
+        "bbox": [
+            174,
+            476,
+            825,
+            558
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Evaluating on Large-scale datasets ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            575,
+            455,
+            589
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the scalability of GGD, we choose three large-scale datasets from Open Graph Benchmark [29], which are ogbn-arxiv, ogbn-products, and ogbn-papers100M. ogbn-papers100M is the most challenging large-scale graph available in Open Graph Benchmark for node property prediction with over 1 billion edges and 110 million nodes. Extending to extremely large graphs (i.e., ogbnproducts and ogbn-papers100M), we adopt a Neighbourhood Sampling strategy, which is described in Appendix A.8. ",
+        "bbox": [
+            173,
+            599,
+            826,
+            681
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ogbn-arxiv & ogbn-products. For ogbn-arxiv, we compare GGD against four self-supervised baselines (i.e., DGI [10], GRACE [13], BGRL [15]and GBT [14]), whereas BGRL [15] and GBT [14] are selected to be compared for ogbn-products. In addition, we include the performance of MLP, Node2vec [32], and supervised GCN [19] sourced from [29] in Table 8 and Table 9. For memory and training time comparison, we only compare GGD with the two most efficient baselines (i.e., BGRL and GBT according to Tables 6 and 7). In ogbn-arxiv, we reproduce BGRL [15] and found it fails to process ",
+        "bbox": [
+            176,
+            691,
+            472,
+            882
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/cec3c68397ea7aaaa95b9b27bc184f2bd10c62ac0302467f096607319f103b22.jpg",
+        "table_caption": [
+            "Table 8: Node classification result and efficiency comparison on ogbn-arxiv. ‘epo’ means epoch. ‘Time’ means training time per epoch (in seconds). ‘Total’ is total training time (Number of epochs $\\times$ ‘Time’). OOM indicates out-of-memory on Nvidia A40 (48GB). Number after \\ means the hidden size of GGD. "
+        ],
+        "table_footnote": [
+            "ogbn-arxiv in full batch. Thus, we only compare GGD and GBT in this dataset, which can successfully train in full-graph processing mode. "
+        ],
+        "table_body": "<table><tr><td>Method</td><td>Valid</td><td>Memory</td><td>Time</td><td>Total</td></tr><tr><td>Supervised GCN</td><td>73.0±0.2 71.7±0.3</td><td></td><td>=</td><td></td></tr><tr><td>MLP</td><td>57.7±0.4 55.5±0.2</td><td></td><td></td><td></td></tr><tr><td>Node2vec</td><td>71.3±0.1 70.1±0.1</td><td></td><td></td><td></td></tr><tr><td>DGI</td><td>71.3±0.1 70.3±0.2</td><td></td><td></td><td></td></tr><tr><td>GRACE(10k epos)</td><td>72.6±0.2 71.5±0.1</td><td></td><td></td><td></td></tr><tr><td>BGRL(10k epos)</td><td>72.5±0.1 71.6±0.1</td><td>OOM (Full-graph)</td><td>/</td><td>/</td></tr><tr><td>GBT(300 epos)</td><td>71.0±0.1 70.1±0.2</td><td>14.959MB</td><td></td><td>6.47 1,941.00</td></tr><tr><td>GGD(1 epo\\1500)</td><td>72.7±0.3 71.6±0.5</td><td>14.666MB</td><td></td><td>0.95 0.9512.043×</td></tr><tr><td>GGD(1 epo\\256)</td><td>71.0±0.2 70.3±0.3</td><td>4,513MBl69.8%</td><td></td><td>0.18 0.18|10,783×</td></tr></table>",
+        "bbox": [
+            486,
+            776,
+            813,
+            878
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "From Table 8 and Table 9, we can see GGD remarkably achieves the state-of-the-art performance using only one epoch to train. As a result, GGD is 10,783 times faster than the most efficient baseline, i.e., GBT [14], on total training time to reach the desirable performance in ogbn-arxiv. Please note that the number of epoches in our experiment is consistent with the optimal choice ",
+        "bbox": [
+            174,
+            92,
+            485,
+            202
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/e8430dcef6047e94556cee3608aee6b0ea712ed2a780d82d4d91d767be44e334.jpg",
+        "table_caption": [
+            "Table 9: Node classification result and efficiency comparison on ogbn-products. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Valid</td><td>Test</td><td>Memory</td><td>Time</td><td>Total</td></tr><tr><td>Supervised GCN</td><td>92.0±0.0</td><td>75.6±0.2</td><td>-</td><td>-</td><td></td></tr><tr><td>MLP</td><td>75.5±0.0</td><td>61.1±0.0</td><td></td><td></td><td></td></tr><tr><td>Node2vec</td><td>70.0±0.0</td><td>68.8±0.0</td><td></td><td></td><td></td></tr><tr><td>BGRL(100 epos)</td><td>78.1±2.1</td><td>64.0±1.6</td><td>29,303MB</td><td></td><td>53m16s 5.326m40s</td></tr><tr><td>GBT(100 epos)</td><td>85.0±0.1</td><td>70.5±0.4</td><td>20.419MB</td><td></td><td>48m38s 4.863m20s</td></tr><tr><td>GGD(1 epo)</td><td>90.9±0.5</td><td>75.7±0.4</td><td>4,391MBl78.5%12m46s 12m46sl381x</td><td></td><td></td></tr></table>",
+        "bbox": [
+            498,
+            112,
+            823,
+            190
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "of this hyperparameter specified in GBT [14]. For ogbn-products, we are $3 8 1 \\mathrm { ~ \\times ~ }$ faster than GBT [14] on total training time. Notably, our performance is significantly higher than GCL baselines using 100 epochs (i.e., $6 \\%$ and $5 . 2 \\%$ improvement on GBT [14] in validation and test set, respectively) with only one epoch training in this dataset. In addition, we compare the convergence speed among GGD, BGRL [15] and GBT [14] on ogbn-arxiv and ogbn-products, which are shown in Figure 4. For ogbn-arxiv, BGRL [15] is running using batched processing with neighbour sampling. This figure shows the preeminence of our GGD in convergence speed as GGD can be well-trained with only one epoch (i.e., reaching the peak model performance in the first epoch and staying stable with increased epochs). In contrast, the other two baselines require comparatively much more epochs to gradually improve their performance. Compared with GCL baselines, GGD achieves much faster convergence via Group Discrimination. We conjecture this is because GD-based method focuses on the general edge distribution of graphs instead of node-specific information. Inversely, GCL methods can suffer from convergence inefficiency as they may be easily distracted from too-detailed node-specific information during training. ",
+        "bbox": [
+            173,
+            202,
+            826,
+            395
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ogbn-papers100M. We further compare GGD with BGRL [15] and GBT [14] on ogbn-papers100M, the largest OGB dataset with billion scale edges. Other self-supervised learning algorithms such as DGI [10] and GMI [12] fail to scale to such a large graph with a reasonable batch size (i.e., 256). We only report the performance of each algorithm after a single epoch of training in Table 10 due to the extreme scale of the dataset and the limitation of our available re",
+        "bbox": [
+            173,
+            401,
+            421,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/369404741420a9881e06aace9ef0fa35449dda32773f5aba54e1e7e7eefff56b.jpg",
+        "image_caption": [
+            "Figure 4: Convergence speed comparison among GGD, BGRL[15] and GBT [14]. X-axis means number of epochs, while Y-axis represents the accuracy on test set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            434,
+            407,
+            795,
+            517
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "sources. From the table, we can observe that GGD outperforms the two GCL counterparts, BGRL [15] and GBT [14] in both accuracy and efficiency. Specifically, GGD achieves 60.2 in accuracy while BGRL and GBT reach 59.3 and 58.9 in test set, respectively. With only one epoch, these two algorithms may not be well trained. However, training each epoch of these two requires over 1 day and if we would like to train them for 100 epochs, then we will need $1 0 0 +$ GPU days, which is prohibitively impractical for general practitioners. In contrast, GGD can be trained in about 9 hours to achieve a good result for this dataset, which is more appealing in practice. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            678
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Explore Group Discrimination ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            696,
+            459,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we explore the corruption technique in GGD and provide the theoretical analysis of group discrimination. ",
+        "bbox": [
+            173,
+            729,
+            825,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.1 Exploring Corruption ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            775,
+            366,
+            790
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Firstly, we explore the corruption technique used in DGI [10] and MVGRL [11], which is shown in Figure 5. These two studies corrupt the topology of a given graph G by shuffling the feature matrix $\\mathbf { X }$ . This is because by changing the node order of $\\mathbf { X }$ , the neighbouring structure of G is completely changed, e.g., neighbours of node $a$ become node $b$ neighbours. ",
+        "bbox": [
+            174,
+            800,
+            485,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/d7632730797410f72a5033c204d9f0922f58ff0a89004851ed992ec19e53587b.jpg",
+        "table_caption": [
+            "Table 10: Node classification result and efficiency comparison on ogbn-papers100M. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Validation</td><td>Test</td><td>Memory</td><td>Time</td></tr><tr><td>Supervised SGC</td><td>63.3±0.2</td><td>66.5±0.2|</td><td>-</td><td>-</td></tr><tr><td>MLP</td><td>47.2±0.3</td><td>49.6±0.3</td><td>·</td><td>=</td></tr><tr><td>Node2vec</td><td>55.6±0.0</td><td>58.1±0.0</td><td>-</td><td>-</td></tr><tr><td>BGRL (1 epoch)</td><td>59.3±0.5</td><td>62.1±0.3</td><td>14,057MB</td><td>26h28m</td></tr><tr><td>GBT(1 epoch)</td><td>58.9±0.4</td><td>61.5±0.5</td><td>13,185MB</td><td>24h38m</td></tr><tr><td>GGD(1 epoch)</td><td>60.2±0.3</td><td>63.5±0.5</td><td>4,105MBl68.9% 9h15ml2.7×</td><td></td></tr></table>",
+        "bbox": [
+            498,
+            829,
+            813,
+            916
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "With the corruption technique, negative samples in the negative group are generated with incorrect edges. Thus, by discriminating the positive group (i.e., nodes generated with ground truth edges) and the negative group, we conjecture the model can distil valuable signals by learning how to identify nodes generated with correct topology and output effective node embeddings. To provide explanation to this, we present the theoretical analysis of group discrimination in the following section. ",
+        "bbox": [
+            173,
+            92,
+            825,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6.1.1 Theoretical Analysis of Group Discrimination ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            193,
+            544,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Group discrimination is learning to avoid making ‘mistakes’ (i.e., bias the encoder towards avoiding mistaken samples). To explain this point, we first present Theorem 1 and then provide an intuitive explanation for group discrimination. ",
+        "bbox": [
+            174,
+            223,
+            465,
+            306
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/3734132db1045b5ec7bbf7c9dacdc5503ab585b756c7fe339d5873634c35c1d5.jpg",
+        "image_caption": [
+            "Figure 5: Corruption technique in DGI and MVGRL. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            483,
+            222,
+            816,
+            291
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 Given a graph G, a corrupted   \ngraph ${ \\widetilde { \\mathsf { S } } } ,$ , and a encoding network $g ( \\cdot )$ , we consider the distribution of positive embeddings $g ( \\mathcal { G } )$ as $P _ { p o s }$ and negative embeddings $g ( \\tilde { \\mathcal { G } } )$ as $P _ { n e g }$ . Optimising the group discrimination loss is equivalent to maximising the Jensen-Shannon divergence between $P _ { p o s }$ and $P _ { n e g }$ . ",
+        "bbox": [
+            174,
+            325,
+            825,
+            387
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The proof for Theorem 1 is presented in Appendix A.2. From the theorem above, we can see maximising the group discrimination loss $\\mathcal { L }$ is the same as maximising $J S ( P _ { p o s } \\parallel P _ { n e g } )$ , where $J S$ represents the Jenson-Shannon divergence. Thus, by optimising the loss $\\mathcal { L }$ , $P _ { p o s }$ and $P _ { n e g }$ tend to be separated. As a result, group discrimination is intuitively learning to avoid making ‘mistakes’ (i.e., bias the encoder towards avoiding mistaken samples) as shown in Figure 6. This is because by separating $P _ { p o s }$ and $P _ { n e g }$ , $P _ { p o s }$ can gradually become similar to $P _ { o p t i m a l }$ , the optimal distribution for node embeddings. As $P _ { o p t i m a l }$ , is disjoint with $P _ { n e g }$ , if the generated embeddings can avoid being similar to out-of-distribution samples, i.e., negative samples, it can be ideally closer to $P _ { o p t i m a l }$ . Therefore, the trained model can improve the quality of generated node embeddings for node samples. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            542
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Future Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            313,
+            597
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have introduced a new self-supervised GRL paradigm: Group Discrimination, which achieves the same level of performance as GCL methods with much less resource consumption (i.e., training time and memory). Some limitations of this work are we still have not explored some questions for GD. For example, can we extend the current binary Group Discrimination scheme (i.e., classifying nodes generated with different topology) to discrimination among multiple groups? Are there any other corruption tech",
+        "bbox": [
+            174,
+            621,
+            387,
+            856
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/3dcd4dfa5eb1418c564634e60ad5c8f101c15fec5f400327bbc709da259065ba.jpg",
+        "image_caption": [
+            "Figure 6: $P _ { o p t i m a l }$ is the optimal distribution for node embeddings, $P _ { p o s }$ is the distribution of positive samples, $P _ { n e g }$ is the distribution of negative samples, blue nodes represent negative samples, and red nodes are samples in the optimal distribution. At the beginning, $P _ { p o s }$ is overlapped with $P _ { n e g }$ . Then, $P _ { p o s }$ is gradually separated from $P _ { n e g }$ and ideally become closer to $P _ { o p t i m a l }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            406,
+            626,
+            820,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "nique to create a more difficult negative group for discrimination? More importantly, with the extremely efficient property, GD has the potential to be deployed to various real-world applications, e.g., recommendation systems, which have limited labelling information and desire fast computation with limited resources. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This research was partially supported by an Australian Research Council (ARC) Future Fellowship (FT210100097). ",
+        "bbox": [
+            176,
+            121,
+            825,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work is supported in part by NSF under grants III-1763325, III-1909323, III-2106758, and SaTC-1930941. ",
+        "bbox": [
+            178,
+            154,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            202,
+            267,
+            218
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Ming Jin, Yizhen Zheng, Yuan-Fang Li, Chen Gong, Chuan Zhou, and Shirui Pan. Multi-scale contrastive siamese networks for self-supervised graph representation learning. IJCAI, 2021.   \n[2] Yue Tan, Guodong Long, Jie Ma, Lu Liu, Tianyi Zhou, and Jing Jiang. Federated learning from pre-trained models: A contrastive learning approach. In First Workshop on Pre-training: Perspectives, Pitfalls, and Paths Forward at ICML 2022.   \n[3] Yue Tan, Guodong Long, Lu Liu, Tianyi Zhou, Qinghua Lu, Jing Jiang, and Chengqi Zhang. Fedproto: Federated prototype learning across heterogeneous clients. In AAAI Conference on Artificial Intelligence, volume 1, page 3, 2022.   \n[4] He Zhang, Bang Wu, Xingliang Yuan, Shirui Pan, Hanghang Tong, and Jian Pei. Trustworthy graph neural networks: Aspects, methods and trends. arXiv preprint arXiv:2205.07424, 2022.   \n[5] He Zhang, Bang Wu, Xiangwen Yang, Chuan Zhou, Shuo Wang, Xingliang Yuan, and Shirui Pan. Projective ranking: A transferable evasion attack method on graph neural networks. In CIKM, 2021.   \n[6] Ming Jin, Yuan-Fang Li, and Shirui Pan. Neural temporal walks: Motif-aware representation learning on continuous-time dynamic graphs. In Advances in Neural Information Processing Systems, 2022.   \n[7] Ming Jin, Yu Zheng, Yuan-Fang Li, Siheng Chen, Bin Yang, and Shirui Pan. Multivariate time series forecasting with dynamic graph neural odes. arXiv preprint arXiv:2202.08408, 2022.   \n[8] Yixin Liu, Zhao Li, Shirui Pan, Chen Gong, Chuan Zhou, and George Karypis. Anomaly detection on attributed networks via contrastive self-supervised learning. TNNLS, 2021.   \n[9] Yizhen Zheng, Vincent Lee, Zonghan Wu, and Shirui Pan. Heterogeneous graph attention network for small and medium-sized enterprises bankruptcy prediction. In PAKDD, pages 140–151. Springer, 2021.   \n[10] Petar Velickovi ˇ c, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon Hjelm. ´ Deep graph infomax. ICLR, 2019.   \n[11] Kaveh Hassani and Amir Hosein Khasahmadi. Contrastive multi-view representation learning on graphs. In ICML, pages 4116–4126. PMLR, 2020.   \n[12] Zhen Peng, Wenbing Huang, Minnan Luo, Qinghua Zheng, Yu Rong, Tingyang Xu, and Junzhou Huang. Graph representation learning via graphical mutual information maximization. In WWW, pages 259–270, 2020.   \n[13] Yanqiao Zhu, Yichen Xu, Feng Yu, Qiang Liu, Shu Wu, and Liang Wang. Deep graph contrastive representation learning. ICML Workshop on Graph Representation Learning and Beyond, 2020.   \n[14] Piotr Bielak, Tomasz Kajdanowicz, and Nitesh V Chawla. Graph barlow twins: A self-supervised representation learning framework for graphs. arXiv preprint arXiv:2106.02466, 2021.   \n[15] Shantanu Thakoor, Corentin Tallec, Mohammad Gheshlaghi Azar, Rémi Munos, Petar Velickovi ˇ c, and ´ Michal Valko. Bootstrapped representation learning on graphs. ICLR2021, 2021.   \n[16] Jean-Bastien Grill, Florian Strub, Florent Altché, Corentin Tallec, Pierre H Richemond, Elena Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Daniel Guo, Mohammad Gheshlaghi Azar, et al. Bootstrap your own latent: A new approach to self-supervised learning. NIPS, 2020.   \n[17] Jure Zbontar, Li Jing, Ishan Misra, Yann LeCun, and Stéphane Deny. Barlow twins: Self-supervised learning via redundancy reduction. In ICML, pages 12310–12320, 2021.   \n[18] Yuning You, Tianlong Chen, Yongduo Sui, Ting Chen, Zhangyang Wang, and Yang Shen. Graph contrastive learning with augmentations. NIPS, 33:5812–5823, 2020.   \n[19] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. ICLR, 2017.   \n[20] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. ´ Graph attention networks. ICLR, 2018.   \n[21] Yizhen Zheng, Ming Jin, Shirui Pan, Yuan-Fang Li, Hao Peng, Ming Li, and Zhao Li. Towards graph self-supervised learning with contrastive adjusted zooming. arXiv preprint arXiv:2111.10698, 2021.   \n[22] Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying graph convolutional networks. In ICML, pages 6861–6871. PMLR, 2019.   \n[23] William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NIPS, pages 1025–1035, 2017.   \n[24] Wei-Lin Chiang, Xuanqing Liu, Si Si, Yang Li, Samy Bengio, and Cho-Jui Hsieh. Cluster-gcn: An efficient algorithm for training deep and large graph convolutional networks. In KDD, pages 257–266, 2019.   \n[25] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. ICLR, 2019.   \n[26] Aleksandar Bojchevski, Johannes Klicpera, Bryan Perozzi, Amol Kapoor, Martin Blais, Benedek Rózemberczki, Michal Lukasik, and Stephan Günnemann. Scaling graph neural networks with approximate pagerank. In KDD, pages 2464–2473, 2020.   \n[27] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.   \n[28] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. arXiv preprint arXiv:1811.05868, 2018.   \n[29] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. NIPS, 2020.   \n[30] Sheng Wan, Shirui Pan, Jian Yang, and Chen Gong. Contrastive and generative graph convolutional networks for graph-based semi-supervised learning. AAAI, 2020.   \n[31] Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. In ICML, pages 40–48. PMLR, 2016.   \n[32] Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In KDD, pages 855–864, 2016.   \n[33] Behzad Kamgar-Parsi, Behrooz Kamgar-Parsi, and Menashe Brosh. Distribution and moments of the weighted sum of uniforms random variables, with applications in reducing monte carlo simulations. Journal of Statistical Computation and Simulation, 52(4):399–414, 1995.   \n[34] Jean Daunizeau. Semi-analytical approximations to statistical moments of sigmoid and softmax mappings of normal variables. arXiv preprint arXiv:1703.00091, 2017.   \n[35] 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": [
+            174,
+            224,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            828,
+            723
+        ],
+        "page_idx": 11
+    }
+]