Learning guarantees: Having established an upper bound, in Theorem 4.2 we again show how a learning-theoretic result follows from standard online learning. This time, instead of OGD we run exponentiated gradient (EG) [44], a classic method for learning from experts, on each of n simplices to learn the probabilities p [ j ] ∀ j ∈ [ n ] . EG updates by multiplying the current vector by the exponent of the negative gradient and is notable for having regret logarithmic in the size |K| of the simplices, which is important for large metric spaces. Note that as the relaxation is randomized, our algorithms output a dense probability vector; to obtain a prediction for OPM we sample ˆ s t [ j ] ∼ p [ j ] ∀ j ∈ [ n ] .

Learning guarantees: Having established an upper bound, in Theorem 4.2 we again show how a learning-theoretic result follows from standard online learning. This time, instead of OGD we run exponentiated (sub)gradient ( EG ) [44], a classic method for learning from experts, on each of n simplices to learn the probabilities p [ j ] ∀ j ∈ [ n ] . The multiplicative update x t +1 ∝ x t (cid:12) exp( − α ∇ U t ( x t )) of EG is notable for yielding regret logarithmic in the size |K| of the simplices, which is important for large metric spaces. Note that as the relaxation is randomized, our algorithms output a dense probability vector; to obtain a prediction for OPM we sample ˆ s t [ j ] ∼ p [ j ] ∀ j ∈ [ n ] .


This paper studies the generalization performance of the gradient-based meta learning with an overparameterized model. For a precise analysis, we focus on linear models where the total number of data from all tasks is smaller than the dimension of the model parameter. We show that when the data heterogeneity across tasks is relatively small, the per-task data covariance matrices with certain properties lead to benign overﬁtting for gradient-based meta learning with the minimum-normsolution. This explains why overparameterized meta learning models can generalize well in new data and new tasks. Furthermore, our theory shows that overﬁtting is more likely to happen in metalearning than in ERM, especially when the data heterogeneity across tasks is relatively high. Onelimitation of this work is that the analysis focuses on themeta linearregression case. While thisanalysis can capture practical cases where we reuse the feature extractor from pre-trained models andonly meta-train the parameters in the last linear layer, it is also promising to extend our analysis tononlinear cases via means of random features and neural tangent kernels in the future work.

This paper studies the generalization performance of the nested meta learning with an overparameterized model. For a precise analysis, we focus on linear models where the total number of data from all tasks is smaller than the dimension of the model parameter. We show that when the data heterogeneity across tasks is relatively small, the per-task data covariance matrices with certain properties lead to benign overﬁtting for nested meta learning with the minimum norm solution. This explains why overparameterized meta learning models can generalize well in new data and new tasks. Furthermore, our theory shows that overﬁtting is more likely to happen in nested meta learning than in ERM, especially when the data heterogeneity across tasks is relatively high in meta learning. Though ourcurrent analysis is limited to the linear models and non-Bayesian estimate, it is possible to extendit for analyzing Bayesian meta learning with more general fully connected or convolutional neuralnetworks in the neural tangent kernel regime. We will pursue those in our future work.

Instruction: Exclude unnecessary reasoning, correct the typos.

Instruction: Improve the english of this paragraph, particularly the last part. Replace all mentions of "gradient-based meta learning" with "nested meta learning".


In the original NS-RNN, the controller can read the probability distribution over the PDA’s current top stack symbol, but it cannot read the PDA’s current state at all. To see why this is a problem, consider the language { 𝑣𝑣 R } . While reading 𝑣 , the controller should predict the uniform distribution over { 0 , 1 } , but while reading 𝑣 R , it should predict based on the top stack symbol. The PDA is able to guess whether the current position is in 𝑣 or 𝑣 R , but this information is kept in the state, not the stack. Consequently, the controller has no way to know which prediction strategy to use. In the RNS-RNN, the stack WFA computes a joint distribution over top stack symbols and PDA states, making r 𝑡 a vector of size | 𝑄 || Γ | . Equation 5 becomes

In the NS-RNN, the controller can read the distribution over the PDA’s current top stack symbol, but it cannot observe its current state. To see why this is a problem, consider the language { 𝑣𝑣 R } . While reading 𝑣 , the controller should predict the uniform distribution, but while reading 𝑣 R , it should predict based on the top stack symbol. A PDA with two states can nondeterministically guess whether the current position is in 𝑣 or 𝑣 R . The controller should interpolate the two distributions based on the weight of being in each state, but it cannot do this without input from the stack WFA, since the state is entangled with the stack contents. We solve this in the RNS-RNN by computing a joint distribution over top stack symbols and PDA states, making r 𝑡 a vector of size | 𝑄 || Γ | . Equation 5 becomes


We use Lancichinetti–Fortunato–Radicchi (LFR) graph generator. It generates non-weighted graphs with ground truth non-overlapped communities. The model has mandatory parameters: the number of nodes n ( n > 0 ), the power law exponent for the degree distribution τ 1 ( τ 1 > 1 ), the power law exponent for the community size distribution τ 2 ( τ 2 > 1 ), the fraction of intra-community edges incident to each node µ ( 0 ≤ µ ≤ 1 ), and either minimum degree (min degree) or average degree (avg degree). There are also extra parameters: maximum degree (max degree), minimum community size (min community), maximum community size (max community). Not all LFR parameters space correspondsreal world graphs, usually real graphs correspond to  τ 1 ∈ [1 , 4] and µ < 0 . However, there is also separated interesting case of bisect graphs ( µ > 0 . 5 ). We still consider the entire parameter space to cover all the cases.

We use Lancichinetti–Fortunato–Radicchi (LFR) graph generator. It generates non-weighted graphs with ground truth non-overlapping communities. The model has mandatory parameters: the number of nodes n ( n > 0 ), the power law exponent for the degree distribution τ 1 ( τ 1 > 1 ), the power law exponent for the community size distribution τ 2 ( τ 2 > 1 ), the fraction of intra-community edges incident to each node µ ( 0 ≤ µ ≤ 1 ), and either minimum degree (min degree) or average degree (avg degree). There are also extra parameters: maximum degree (max degree), minimum community size (min community), maximum community size (max community). Not the whole LFR parameter space corresponds to common real-world graphs; most of such graphs are described with τ 1 ∈ [1 , 4] and µ < 0 . However, there is also an interesting case of bipartite/multipartite-like graphs with µ > 0 . 5 . Our choice is to consider the entire parameter space to cover all theoretical and practical cases.

Instruction: Correct the grammar error.


Ablations : Figure 5 shows ablation results on test actions. Grid World : all ablations utilize the summary of action set  as input, aggregated via different mechanisms. Thus, they can identify which dig-lava skills are available and guide each action decision accordingly. In such small action spaces with simple action relations, summary-ablations are on par with AGILE. This  also holds true for RecSim and Real RecSys , where the information of the most common category is sufﬁcient to select the same category’s items  to maximize CPR (e.g. Figure 6(c)). Therefore, we observe only 5 − 20% gains of AGILE over the ablations. To test  consistency of results, we further evaluate on two more RecSim tasks: (i) Direct CPR: task is still to maximize CPR, but agent receives additional  CPR metric reward on top of click/no-click reward (Sec B.3, and (ii) Pairing environment:  task is to recommend pairs of associated items based on predeﬁned pairings. We reproduce the trend that AGILE > = ablations.

Ablations : Figure 5 shows ablation results on test actions. Grid World : all ablations utilize the action set summary as input, aggregated via different mechanisms. Thus, they can identify which dig-lava skills are available and enter lava accordingly to create shortcuts. In such small action spaces with simple action relations, summary-ablations are on par with AGILE. This trend also holds for RecSim and Real RecSys , where the summary can ﬁnd the most common category and its items are then selected to maximize CPR (e.g., Figure 6(c)). Therefore, we observe only 5 − 20% gains of AGILE over the ablations. To test the consistency of results, we further evaluate two more RecSim tasks. (i) Direct CPR: the agent receives additional explicit CPR metric reward on top of click/noclick reward (Sec. B.3), and (ii) pairing environment: the task is to recommend pairs of associated items based on predeﬁned pairings (Sec. B.4). We reproduce the trend that AGILE > = ablations.

Instruction: Correct some issues in the paragraph and replace certain words to improve it

Instruction: Improve the overall clarity of the paragraph.


To convert text classiﬁcation into the node classiﬁcation on graph, there are two relationships considered when forming graphs: (i) the relation between documents and words and(ii) the connection between words. For the ﬁrst type of relations, we build edges among word nodes and document nodes based on the word occurrence in documents. The weight of the edge between a document node and a word node is the Term Frequency-Inverse Document Frequency (Rajaraman & Ullman,  2011) (TF-IDF) of the word in the document applied to build the Docs-words graph. For the second type of relations, we build edges in graph among word co-occurrences across the whole corpus. To utilize the global word co-occurrence information, we use a ﬁxed-size sliding window on all documents in the corpus to gather co-occurrence statistics. Point-wise Mutual Information (Church &

For Text GCN, SGC, and our approach, the embedding size of the ﬁrst convolution layer is 200 and the window size is 20. We set the learning rate to 0.02, dropout rate to 0.5 and the decay rate to 0. The 10% of training set is randomly selected for validation. Following (Kipf & Welling, 2016), we trained our method and Text GCN for a maximum of 200 epochs using the Adam (Kingma & Ba, 2014) optimizer, and we stop training if the validation loss does not decrease for 10 consecutive epochs. The text graph was built according to steps detailed in the supplementary material. To convert text classiﬁcation into the node classiﬁcation on graph, there are two relationships considered when forming graphs: (i) the relation between documents and words and (ii) the connection between words. For the ﬁrst type of relations, we build edges among word nodes and document nodes based on the word occurrence in documents. The weight of the edge between a document node and a word node is the Term Frequency-Inverse Document Frequency (Rajaraman & Ullman,  2011) (TF-IDF) of the word in the document applied to build the Docs-words graph. For the second type of relations, we build edges in graph among word co-occurrences across the whole corpus. To utilize the global word co-occurrence information, we use a ﬁxed-size sliding window on all documents in the corpus to gather co-occurrence statistics. Point-wise Mutual Information (Church &


X t,j is encoded by its user into a message Y t,j , and then transmitted to a central server. We assume that the communication with the server for each datapoint takes no more than b bits. This paper mainly addresses the communication bottleneck and does not involve privacy concerns.

X t,j is encoded by its user into a message Y t,j , and then transmitted to a central server. We assumethe server knows which cluster t ∈ [ T ] each transmitted datapoint Y t,j belongs to, as well as thenumber of clusters T . We assume that the communication with the server for each datapoint takes no more than b bits. This paper mainly addresses the communication bottleneck and does not involve privacy concerns.


Another line of methods, on the contrary, uses the returns of the behavior policy as the signal for policy learning, as adopted in (Wang et al., 2018; Peng et al., 2019; Chen et al., 2020). By doing so, they keep the whole learning procedure  within the dataset’s support. However, the behavior policy of the dataset can be imperfect and insufﬁcient to guide policy learning. Learning optimal values within the dataset, on the other extreme, can lead to erroneously optimistic value estimates since data is limited and off-policy. To achieve a trade-off between imitation learning and optimal value learning, we propose Expectile V -learning (EVL), which is based on a new expectile operator that smoothly interpolates between the Bellman expectation operator and optimality operator.

Another line of methods, on the contrary, uses the returns of the behavior policy as the signal for policy learning, as adopted in Wang et al. ; Peng et al. ; Chen et al. By doing so, they keep the value learning procedure completely within the dataset . However, the behavior policy of the dataset can be imperfect and insufﬁcient to guide policy learning. To achieve a tradeoff between imitation learning and optimal value learning while conﬁnes learning within the dataset , we propose Expectile V -learning (EVL), which is based on a new expectile operator that smoothly interpolates between the Bellman expectation operator and optimality operator.

Instruction: Remove a redundant sentence. Correct citation format.

Instruction: Make it shorter by removing what is not essential.


N: to achieve a large explosive yield, a linear implosion weapon needs more material, about 13 kgs. Q: the mint ’s director at the time , nicolas peinado , was also an architect and made the initial plans. N: jetley ’s mother , kaushaliya rani , was the daughter of high court advocate shivram jhingan . Q: their ﬁrst project is software that lets players connect the company ’s controller to their device N: the city offers a route-ﬁnding website that allows users to map personalized bike routes

NT: to achieve a large explosive yield, a linear implosion weapon needs more material, aboutkgs. Q: the mint ’s director at the time , nicolas peinado , was also an architect and made the initial plans. N: the director is angry at crazy loop and glares at him , even trying to get a woman to kick crazy loop out of the show ( which goes unsuccessfully ) . NT: jetley ’s mother , kaushaliya rani , was the daughter of high court advocate shivram jhingan . Q: their ﬁrst project is software that lets players connect the company ’s controller to their device N: you could try use norton safe web , which lets you enter a website and show whether there seems to be anything bad in it . NT: the city offers a route-ﬁnding website that allows users to map personalized bike routes


Encoder Network The encoder network starts with two multi-layer perceptrons (MLPs) that generate embeddings for each  single amino acid and each pair of amino acids respectively. The MLP for single amino acid encodes the amino acid type, backbone dihedral angles, and local atom coordinates of each amino acid into a vector e i ( i = 1 . . . n ). The other MLP for amino acid pairs mainly encodes the distance and  relative position between two amino acids and we denote a pair embedding vector as z ij ( i, j = 1 . . . n ). Next, we use a self-attention-based network invariant to rotation and translation (Jumper et al., 2021) to transform the single embeddings{ e i} and pair embeddings{ z ij} into hidden representations{ h i } . The hidden representation h i is aimed at capturing the informa- tion of both the i -th amino acid itself and its structural environments. It serves as an encoding of the condition { a j , p j , O j , ˜ χ j } nj =1 for the probability density w.r.t. χ i .

Encoder Network The encoder network starts with two multi-layer perceptrons (MLPs) that generate embeddings for each individual single residue and each pair of residues respectively. The MLP for single residues encodes the residue type, backbone dihedral angles, and local atom coordinates into a vector e i ( i = 1 . . . n ). The other MLP for residue pairs encodes the distance and the relative position between two residues. We denote a pair embedding vector as z ij ( i, j = 1 . . . n ). To transform the single embeddings e i and pair embeddings z ij into hidden representations h i , we use a self-attention-based network that is invariant to rotation and translation (Jumper et al., 2021). The hidden representation h i aims to capture both the information of the i -th residue itself and its structural environment. It serves as an encoding of the condition { a j , p j , O j , ˜ χ j } nj =1 for the probability density with respect to χ i .

Instruction: Replace every apparition of "amino acids" or "amino acids in the protein complex" by "residues"

Instruction: Replace all mentions of amino acid by 'residue'. Reorder sentences in a more logical order when needed.


However, as shown in Figure 2 (a), the treatment selection bias shifts covariate distributions across groups. As such, ϕ 1 and ϕ 0 would overfit the respective group’s properties and thus cannot generalize well to the entire population. Therefore, the resulting ˆ τ  would be biased.

However, according to Figure 1(a), the treatment selection bias causes a distribution shift of covariates across groups, which misleads ϕ 1 and ϕ 0 to overfit their respective group’s properties and generalize poorly to the entire population. Therefore, the ITE estimate ˆ τ by these methods would be biased.

Instruction: Improve the english of this paragraph.

Instruction: Edit the paragraph to make it more formal and precise.


Median completion time was 4.0 seconds with Design A , 2.0 seconds with Design B , and 1.0 seconds with Design C . To complete this task with Design A , participants had to scroll to count all the times the medication appeared on a given day. Similar complaints about the need to scroll as for T MED ; day were made by P3, P5, and P8.

All participants successfully completed T MED ; cycle with all de- signs. With Design A , they again had to scroll through the entire week, therefore took longer; with Design B they could rely on the daily summaries; and with Design C the information was readily accessible on the row headers. No comments were made regarding this task.


Sparse reparameterization Successful training of sparse reparameterized networks invariably employed iterative pruning and retraining (e.g. Han et al. ; Narang et al. (2017); Zhu & Gupta (2017)). Training typically started with a large  model and sparsity was scheduled to increase during the course of learning. Training a small,  sparse model de novo always fared much worse than training a large one to begin with (Zhu & Gupta, 2017).

Sparse reparameterization Successful training of sparse reparameterized networks usually employs iterative pruning and retraining, e.g. Han et al. ; Narang et al. (2017); Zhu & Gupta (2017) 3 . Training typically starts with a large pre-trained model and sparsity is gradually increased during the course of ﬁne-tuning. Training a small, static, and sparse model de novo always fared much worse than training a large one to begin with (Zhu & Gupta, 2017).

Instruction: Improve the English of this paragraph.


One can see a qualitative comparison of acLSTM with a basic LSTM-3R in Figure 3, both trained on the Indian dance dataset. We ﬁnd the performance of the vanilla network to be consistent with the results reported in Fragkiadaki et al. ; Jain et al. ; Bütepage et al. ; Martinez et al.

One can see a qualitative comparison of acLSTM with a basic LSTM-3R in Figure 3, both trained on the Indian dance dataset. We ﬁnd the performance of the vanilla network to be consistent with the results reported in (Fragkiadaki et al., 2015; Jain et al., 2016; Bütepage et al., 2017; Martinez et al., 2017), freezing at around 1000 ms.


This issue stems mainly from the mass preservation constraint. Specifically, units acting as outliers at a mini-batch level would be forced to be transported by this marginal constraint, as depicted in Figure 1. It hinders the transport of normal units andmakes the group discrepancy vulnerable to the sampling effect. Such issue would be exacerbated by the small batch size.

This issue is attributed to the mass-preservation constraint in (5), which requires that all units in both groups match each other, regardless of the actual situation. Mini-batch outliers, for instance, would be compelled to be transported according to Figure 2, which impedes the transport of normal units and the computation of the actual group discrepancy. A small batch size would exacerbate this defect.

Instruction: Rewrite so that it looks more organized

Instruction: Rewrite this paragraph to make it more easily readable.


Training Settings. Following (Zhang et al., 2018b), we perform data augmentation on the training images, which are randomly rotated by 90 ◦ , 180 ◦ , 270 ◦ and ﬂipped horizontally. Each training batch consists of 16 LR color patches, whose sizeis 48 × 48. Our SRP model is trained by ADAM optimizer (Kingma & Ba, 2014)  with β 1 =0.9, β 2 =0.999, and (cid:15) = 10 − 8 . We set the initial learning rate as 10 − 4 and then decrease it to half every 2 × 10 5 iterations of back-propagation. We use PyTorch (Paszke et al., 2017) to implement our models with a Tesla V100 GPU 2 .

Training Settings. Following (Zhang et al., 2018b), data augmentation is used in training – training images are randomly rotated by 90 ◦ , 180 ◦ , 270 ◦ and ﬂipped horizontally. Image patches (patch size 48 × 48) are cropped out to form each training batch. Adam optimizer (Kingma & Ba, 2014) is adopted for training with β 1 =0.9, β 2 =0.999, and (cid:15) = 10 − 8 . Initial learning rate is set to 10 − 4 and then decayed by factor 0 . 5 every 2 × 10 5 iterations. We use PyTorch (Paszke et al., 2017) to implement our models with a Tesla V100 GPU † .

Instruction: Improved the writing and reformulate the third sentence

Instruction: Improved the writing and reformulate the third sentence


The other advantage of message passing is that we can utilize the labels of retrieveddata instances to interact with featuresto generate label-enhanced messages, guide the messageaggregation process, and take advantage of label propagation at the same time. After message passing,the enhanced data instance representations are then used for prediction.

Notice that (2-way) factorization machine (Rendle, 2010) solely modelling the second-order featureinteractions is widely employed in real-world scenarios and inspires a series of tabular predictors (Wuet al., 2021b; Qin et al., 2021). Our method leverages the hypergraph structure of the given tabulardata to capture high-order interactions beyond the second-order ones, and uses GNNs to representthese high-order features. The other advantage of message passing is that we can utilize the labels ofretrieved data instances to interact with features and take advantage of label propagation at the sametime. The enhanced data instance representations are then used for prediction.


Because avoid-strategy was shown to be desirable in experiment 2, changing the notch to an area where the cursor cannot enter can be considered. Experiment 3 was almost the same experiment as experiment 2, however, the notch  changed to an area where the cursor cannot enter. The apparatuses, participants, task, and measurements were the same as in experiment 2.

Changing the notch to an area where the cursor cannot enter can be considered as an effective approach as the avoid-strategy was found to be desirable in Experiment 2. Experiment 3 was almost the same experiment as Experiment 2; however, the notch was changed to an area where the cursor cannot enter. The apparatuses, participants, task, and measurements were the same as in Experiment 2.

Instruction: Switch the two parts of the first sentence

Instruction: Reorder the first sentence.


When the pruning process is ﬁnished, we remove the unimportant ﬁlters (not zeroing out them only, but literally removing them from the model), which results in a small model. Then we ﬁnetune the small model  to regain performance following the common practice in pruning (Reed, 1993).

Upon ﬁnishing pruning, we take away the unimportant ﬁlters (not zeroing out them only, but literally removing them from the model), which will give us a compact SR model. Finally, the compact model will be ﬁnetuned to regain performance following the common practice in pruning (Reed, 1993).

Instruction: Please rephrase my paragraph.

Instruction: Revise this academic paragraph for readability.


These earlier negative ﬁndings compel us to ask, what prevents multi-modal DNNs from achieving better performance? In order to answer this question, we ﬁrst introduce a metric, conditional utilization rate . For a multi-modal DNN trained with two modalities, m 0 and m 1 , the conditional utilization rate of m 1 given m 0 , denoted by u ( m 1 | m 0 ) , measures how important it is to use m 1 , given the presence of m 0 . We experiment on several multi-modal learning tasks and we consistently observe a signiﬁcant difference of conditional utilization rates between modalities. For example, we observe u RGB | depth = 0 . 01 and u depth | RGB = 0 . 63 for a model trained to identify gestures in videos using the NVIDIA Dynamic Hand Gesture Dataset (NVGesture) (Molchanov et al., 2016). It indicates that the model relies on the depth modality to make predictions and does not pay attention to the RGB modality. This observation leads to a conjecture that the multi-modal learning process often results in models that under-utilize some of the input modalities.

These earlier negative ﬁndings compel us to ask, what prevents multi-modal DNNs from achieving better performance? In order to answer this question, we ﬁrst diagnose these DNNs as lacking utilization of all modalities by analyzing their conditional utilization rates. For a multi-modal DNN trained with two modalities, m 0 and m 1 , the conditional utilization rate of m 1 given m 0 , denoted by u ( m 1 | m 0 ) , measures how important it is to use m 1 , given the presence of m 0 . It is computed as the relative difference in accuracy between two derived models from the DNN, one using both modalities and the other using only one modality. In several multi-modal learning tasks, we consistently observe a signiﬁcant imbalance in conditional utilization rates between modalities. For example, we observe u (RGB | depth) = 0 . 01 and u (depth | RGB) = 0 . 63 for a DNN trained to identify gestures in videos using the NVIDIA Dynamic Hand Gesture Dataset (NVGesture) (Molchanov et al., 2016). It indicates that the DNN relies on the depth modality to make predictions and does not pay attention to the RGB modality. These observations lead to a conjecture that the multi-modal learning process often results in models that under-utilize some of the input modalities.


Consider the classic differentially private stochastic convex optimization (DP-SCO) (Chaudhuri et al., 2011; Bassily et al., 2014; 2019; 2020b) setting. Let τ be a distribution over a ﬁxed domain D . Given a data set D ∈ D ∗ drawn i.i.d. from τ , and a loss function (cid:96) priv : R p × D → R , the objective is to approximately solve arg min θ ∈C

Consider the classic differentially private stochastic convex optimization (DP-SCO) [6, 9, 11, 13] setting. Let τ be a distribution over a ﬁxed domain D . Given a data set D ∈ D ∗ drawn i.i.d. from τ , and a loss function (cid:96) priv : R p × D → R , the objective is to approximately solve arg min θ ∈C

Instruction: I do not want parenthetical citations.


(2) Regularization Form . Although L 1 regularization is well-known to induce sparsity in machine learning, it is hard to tune the coefﬁcient to strike a good balance between sparsity and performance. Therefore, L 2 regularization is  adopted in our method given its easy control. Speciﬁcally, given the loss function L of a neural network Θ , the total error function E with the proposed adaptive Lregularization term can be formulated as

(2) Regularization Form . Although L 1 regularization is well-known to induce sparsity in machine learning, it is hard to tune the coefﬁcient to realize a desired trade-off between sparsity and performance. Instead, L 2 regularization is thereby adopted in our method given its more tamable control over the sparsiﬁcation process – note the gradient of L 2 regularization is proportion to the weight magnitude while the gradient of L 1 regularization is not. Speciﬁcally, given the loss function L of a neural network Θ , the total error function E with adaptive L 2 regularization term is formulated as


We consider propagating semantic labels from labeled data C to unlabeled data U by exploiting the aforementioned relationships. We denote C and U as the sets of segment indices. Our label propagation is driven by grouping and separating data in a learned feature space. We now describe each pixel-to-segment semantic relationship for augmenting the setsof positive/negative segments using both labeled and unlabeled pixels.

Our goal is to propagate known semantics from labeled data C to unlabeled data U with the aforementioned priors. C and U denote the sets of segment indices respectively. We detail how to augment positive / negative segment sets using both C and U for each type of relationships (Fig. 4).

Instruction: Make this paragraph considerably more concise. Remove any information that is not essential to this paragraph itself.

Instruction: Delete the third sentence. Concise the first and last one.


MLP-based Architectures. MLP-Mixer (Tolstikhin et al., 2021) has designed a very concise framework that utilizes matrix transposition and MLP to transmit information between spatial features. Resort to MLP, skip connection between layers and normalization layer, MLP-Mixer obtains promising experimental results. The concurrent work FF (Melas-Kyriazi, 2021) also applies a similar network architecture and reaches similar conclusions. Such experimental results are surprising, which shows that the MLP-based architecture also achieves comparable performance with CNN-based architectures and transformer-based architectures. Subsequently, Res-MLP (Touvron et al., 2021a) is proposed, which also obtains impressive performance with residual MLP only trained on ImageNet1K. gMLP (Liu et al., 2021a) and EA (Guo et al., 2021) introduce Spatial Gating Unit (SGU) and the external attention to improve the performance of the pure MLP-based architecture, respectively.

MLP-based Architectures. MLP-Mixer (Tolstikhin et al., 2021) designs a very concise framework that utilizes matrix transposition and MLP to transmit information between spatial features, and obtains promising performance. The concurrent work FF (Melas-Kyriazi, 2021) also applies a similar network architecture and reaches similar conclusions. Subsequently, Res-MLP (Touvron et al., 2021a) is proposed, which also obtains impressive performance with residual MLP only trained on ImageNet-1K. gMLP (Liu et al., 2021a) and EA (Guo et al., 2021) introduce Spatial Gating Unit (SGU) and the external attention to improve the performance of the pure MLP-based architecture, respectively.

Instruction: Revise this paragraph to be more concise.

Instruction: Make this paragraph shorter by deleting details.


We develop a notion of projections between sets of probability measures using the geometric properties of the 2 -Wasserstein space. It is designed forgeneral multivariate probability measures, is computationally efﬁcient to implement, and provides a unique solution in regular settings. The idea is to work on regular tangent cones of the Wasserstein space using generalized geodesics. Its structure and computational properties make the method applicable in a variety of settings, from causal inference to the analysis of object data. An application to estimating causal effects yields a generalization of the notion of synthetic controls  for systems with general heterogeneity described via multivariate probability measures, as well as a way to estimate optimal weights jointly over all time periods.

We develop a notion of projections between sets of probability measures using the geometric properties of the 2 -Wasserstein space. In contrast to existing methods, it is designed for multivariate probability measures that need not be regular, is computationally efﬁcient to implement via a linear regression, and provides a unique solution in general. The idea is to work on tangent cones of the Wasserstein space using generalized geodesics. Its structure and computational properties make the method applicable in a variety of settings where probability measures need not be regular, from causal inference to the analysis of object data. An application to estimating causal effects yields a generalization of the synthetic controls method for systems with general heterogeneity described via multivariate probability measures, something that has been out of reach of existing approaches.

Instruction: Please, make this paragraph more clear.


The DINO-based high score images have various face angles while the low score images are mostly front-facing. In the third column of Figure 9, the baby faces appear in the low score images, unlike the other two models which have formal adult images in the low score. This can be explained from the previous study that the CLIP model (Radford et al., 2021), which is a self-supervised image-text multi-modal model, can better capture semantics compared to the classifiers. We conjecture that the model may consider the baby faces more similar between them than between the other images because baby faces are less distinctive and share a lot common properties compared to the adult faces. For the user preference, we present a user study on the feature extractors in Figure 24b in Appendix I. On the noise robustness,  CLIP is more robust to the Gaussian noise or Gaussian blur compared to VGG16, which is summarized in Appendix J.

The DINO-based high score images have various face angles while the low score images are mostly front-facing. In the third column of Figure 9, the baby faces appear in the low score images, unlike the other two models which have formal adult images in the low score. This can be explained from the previous study that the CLIP model (Radford et al., 2021), which is a self-supervised image-text multi-modal model, can better capture semantics compared to the classifiers. We conjecture that the model may consider the baby faces more similar between them than between the other images because baby faces are less distinctive and share a lot common properties compared to the adult faces. For the user preference, we present a user study on the feature extractors for FFHQ dataset and found that VGG16 is the most preferred feature extractor for FFHQ dataset. The detailed experimental setting and results are described in Appendix I. For the noise robustness, on the other hand, we found CLIP is more robust to the Gaussian noise or Gaussian blur compared to VGG for various noise levels. The details are described in Appendix J.


To summarize, our contribution is introducing a framework of the generalized probability kernel(GPK) which in general treats the function space of probability mass function as a subspace of universal-RKHS F . The resulting family of GPK [ F  ] is valuable especially when they are equiped with a plugin-estimator. We introduce a series of techniques in analyzing bias  of these plugin-estimators and illustrate a procedure of searching for members of GPK [ F ] family suitable forapplications such as the two-sample test.

To summarize, our contribution is introducing a framework of the generalized probability kernel(GPK) which treats the function space of probability mass function as a subspace of universalRKHS F . The resulting family of GPK[ F , φ, p , q ] is valuable especially when they are equipped with a plugin-estimator. We introduce a series of techniques in analyzing bias and convergence bounds of these plugin-estimators. Remarkably, a natural extension of MMD from the viewpoint of GPK, which we call power-MMD, could be used for two-sample test. We further argue that the two-sample test using power-MMD with large ρ in general performs better than MMD(which is with small ρ ).


Abstract As Artiﬁcial Intelligence (AI) becomes an integral part of our life, the development of explainable AI, embodied in the decision-making process of an AI or robotic agent, becomes imperative. For a robotic teammate, the ability to generate explanations to explain its behavior is one of the key require- ments of an explainable agency. Prior work on explanation generation focuses on supporting the reasoning behind the robot’s behavior. These approaches, however, fail to consider the cognitive effort needed to understand the received expla- nation. In particular, the human teammate is expected to understand any explanation provided before the task execution, no matter how much information is presented in the explanation. In this work, we argue that an explanation, especially complex ones, should be made in an online fashion during the execution, which helps to spread out the information to be explained and thus reducing the cognitive load of humans. However, a challenge here is that the different parts of an ex- planation are dependent on each other, which must be taken into account when generating online explanations. To this end, a general formulation of online explanation generation is presented. We base our explanation generation method in a model reconciliation setting introduced in our prior work. Our approach is evaluated both with human subjects in a standard planning competition (IPC) domain, using NASA Task Load Index, as well as in simulation with ten different problems.

Abstract —As Artiﬁcial Intelligence (AI) becomes an integral part of our life, the development of explainable AI, embodied in the decision-making process of an AI or robotic agent, becomes imperative. For a robotic teammate, the ability to generate explanations to explain its behavior is one of the key requirements of an explainable agency. Prior work on explanation generation focuses on supporting the reasoning behind the robot’s behavior. These approaches, however, fail to consider the mental workload needed to understand the received explanation. In other words, the human teammate is expected to understand any explanation provided, often before the task execution, no matter how much information is presented in the explanation. In this work, we argue that an explanation, especially complex ones, should be made in an online fashion during the execution, which helps spread out the information to be explained and thus reducing the mental workload of humans. However, a challenge here is that the different parts of an explanation are dependent on each other, which must be taken into account when generating online explanations. To this end, a general formulation of online explanation generation is presented along with three different implementations satisfying different online properties. We base our explanation generation method on a model reconciliation setting introduced in our prior work. Our approaches are evaluated both with human subjects in a standard planning competition (IPC) domain, using NASA Task Load Index (TLX), as well as in simulation with ten different problems across two IPC domains.


On the other hand, neural network pruning is well-known as an effective technique to reduce model complexity (Reed, 1993; Sze et al., 2017). For acceleration, researchers mainly focus on ﬁlter pruning (a.k.a. structured pruning) (Li et al., 2017) rather than weight-element pruning (a.k.a. unstructured pruning) (Han et al., 2015; 2016b). Marrying ﬁlter pruning with image SR seems a plausible solution to strike a better performance-complexity trade-off. However,  ﬁlter pruning methods in classiﬁcation can hardly translate to  SR networks directly. The main reason is that, residual connections are well-known hard to prune in structured pruning (Li et al., 2017) while they are extensively used in state-of-the-art  SR networks (e.g., EDSR (Lim et al., 2017) has 32 residual blocks; RCAN (Zhang et al., 2018b) even has nested residual blocks).

On the other hand, neural network pruning is well-known as an effective technique to reduce model complexity (Reed, 1993; Sze et al., 2017). For acceleration, ﬁlter pruning (a.k.a. structured pruning) (Li et al., 2017) attracts more attention than weight-element pruning (a.k.a. unstructured pruning) (Han et al., 2015; 2016b). Introducing ﬁlter pruning into image SR is a promising solution to achieve a good trade-off between performance and complexity. However, it is not easy to apply ﬁlter pruning methods to image SR networks directly. This is mainly because residual connections are well-known difﬁcult to prune in structured pruning (Li et al., 2017). On the other hand, they are extensively used in state-of-the-art (SOTA) image SR methods (e.g., EDSR (Lim et al., 2017) hasresidual blocks; RCAN (Zhang et al., 2018b) even has nested residual blocks).

Instruction: Improve the paragraph.

Instruction: Rewrite the third sentence using more appropriate language.


Results. In ﬁg. 1, we plot the average loss against the epoch number based on 30 simulations (runs). The standard deviations of the runs are also illustrated around the average in lighter color as shaded regions. We observe that SAPD and SAPD-VR consistently outperforms over other algorithms. For a9a , gisette , sido0 datasets, the average training accuracy of SAPD are 84 . 43% , and of SAPD-VR are 84 . 46% , respectively. The best performance for a9a , gisette , sido0 among all the other algorithms are 75 . 43% , respectively. More importantly, we observe that as an accelerated method, SAPD-VR enjoys fast convergence properties while still being robust to gradient noise.

Results. To fairly compare the performances of algorithms using different batch sizes, we plot loss against epochs in x-axis 5 . In ﬁg. 1, we plot the average loss against the epoch number based on 30 simulations (runs). The standard deviations of the runs are also illustrated around the average in lighter color as shaded regions. We observe that SAPD+ and SAPD+VR consistently outperforms over other algorithms. For a9a , gisette , sido0 datasets, the average training accuracy of SAPD+ are 84 . 43% , and of SAPD+VR are 84 . 46% , respectively. The best performance for a9a , gisette , sido0 among all the other algorithms are 75 . 43% , respectively. More importantly, we observe that as an accelerated method, SAPD+VR enjoys fast convergence properties while still being robust to gradient noise.


The effect of the linear projection Z ( K ) (ﬁlter) acting on spectrum as f ( λ ) = 1 K (cid:80) {+K k =
+} [-Kk =
-] λ k is plotted in Figure 1, from which we observe the following two properties: (i) Z ( K ) preserves leading (large) eigenvalues of T and (ii) the higher K is the stricter the low-pass ﬁlter becomes. In other words, as K grows, this ﬁlter tries to approximate a low-rank positive semi-deﬁnite matrix by keeping the largest positive eigenvalues. Note the relationship between the normalized Laplacian matrixL andthe corresponding normalized adjacent matrix Twhich is L = I − T , and thus keeping large positive eigenvalues for T equals keeping small eigenvalues for L .

The effect of the linear projection Z ( K ) (ﬁlter) acting on spectrum as f ( λ ) = 1 K (cid:80) {+K k =
+} [-Kk =
-] λ k (we sum from 0 to include self-loops) is plotted in Figure 1, from which we observe the following properties: (i) Z ( K ) preserves leading (large) eigenvalues of T and (ii) the higher K is the stricter the low-pass ﬁlter becomes but the ﬁlter also preserves the high frequency. In other words, as K grows, this ﬁlter includes larger and larger neighborhood but also maintains the closest locality of nodes. Note that L = I − T where L is the normalized Laplacian matrix and T is the normalized adjacency matrix. Thus keeping large positive eigenvalues for T equals keeping small eigenvalues for L .


Training MoEs is typically done end-to-end, with the experts and gate learning simultaneously, andsparse gradients based on the routing. We found this did not lead to good performance with SM O Es and tensor routing, particularly on regression tasks, as the gate did not learn well. Indeed, in suchcases, the gate rarely changed its routing decisions from initialization. We hypothesize that this is dueto a “mismatch” in the gradients on regression tasks, where they are informative for experts but not thegate (see Appendix B). To address this, we train the gate with a separate, self-supervised loss function, the routing classiﬁcation (RC) loss. The key idea is to consider routing as a dense, multi-label classiﬁcation task: selecting the “correct” experts at each point (cf. semantic segmentation). The RC loss does exactly this, and trains the gate by constructing appropriate labels.

Training MoEs is typically done end-to-end, with the experts and gate learning simultaneously,and sparse gradients based on the routing. We found this did not lead to good performance with SM O Es and tensor routing, particularly on regression tasks, as the gate did not learn well: it rarelychanged its routing decisions from initialization. We hypothesize that this is due to a “mismatch” inthe gradients on regression tasks, where they are informative for experts but not the gate, because regression aims to make a continuous prediction over both positive and negative values, whereasselecting an expert requires a threshold (see §B). To address this, we train the gate with a separate, self-supervised loss function, the routing classiﬁcation (RC) loss. The key idea is to consider routing as a dense, multi-label classiﬁcation task: selecting the “correct” experts at each point (cf. semantic segmentation). The RC loss does exactly this, and trains the gate by constructing appropriate labels.


Local Spatial Self-Attention. For smaller i of shallower stages, we expect each token to mainlyfocus on finer-grained information and not to be disturbed by long-range signals. Thus,  we modifythe original self-attention layer by a local spatial constraint that only neighboring tokens within aball query [29] would be available for attention calculation. As the point tokens are downsampled by stages, we set increasing radii { r i } Si =1 of multi-scale ball queries for gradually expanding the attention scopes, which fulfills the local-to-global feature aggregation scheme.

Local Spatial Self-Attention. During pre-training, we expect point tokens in the multi-stage encoder to capture global cues for 3D shapes, which benefits the reconstruction of masked parts. However, when fine-tuning on downstream tasks without masked autoencoding, point tokens in the shallower stages are better to mainly focus on local information and not to be disturbed by long-range signals, referring to the inductive bias of 3D locality [36]. Thus, during fine-tuning, we modify the original self-attention layer in the encoder with a local spatial constraint that only neighboring tokens within a ball query would be available for attention calculation. As the point tokens are downsampled by stages, we set increasing radii { r i } Si =1 of multi-scale ball queries for gradually expanding the attention scopes, which fulfills the local-to-global feature aggregation scheme.


Architecture, training and testing. For all the experiments on  VOC, we base our architecture as DeepLab (Chen et al., 2017) with ResNet101 (He et al., 2016) as  backbone network. For the experiments on DensePose dataset, we adopt PSPNet (Zhao et al., 2017) as  backbone network. We only use models  pre-trained on ImageNet (Deng et al., 2009) dataset. For training our models, we set λ I , λ C , λ O and λ A according to different types of annotations and datasets, which is shown in table 1. For inference, we follow SegSort (Hwang et al., 2019) to perform k-nearest neighbor retrievals. See Appendix for more detail of hyper-parameters and setting for training and testing.

Architecture, training and testing. For all the experiments on PASCAL VOC, we base our architecture on DeepLab (Chen et al., 2017) with ResNet101 (He et al., 2016) as the backbone network. For the experiments on DensePose, we adopt PSPNet (Zhao et al., 2017) as the backbone network. Our models are pre-trained on ImageNet (Deng et al., 2009) dataset. See Appendix for details on our inference procedure and hyper-parameter selection for training and testing.

Instruction: Move the less important details of the training into an appendix.

Instruction: VOC is now named PASCAL VOC. Replace the last two sentence by a reference to an appendix. Correct the english in this paragraph.


Owing to the pruned index constraint problem, many ﬁlter pruning methods in  classiﬁcation simply do not prune the last Conv layer in a residual blocks (Li et al., 2017; Wang et al., 2021), which can still deliver considerable speedup of practical interest. But, this naive solution cannot translate to the image SR networks. The fundamental reason is that image SR networks typically employ much more residual blocks and each block typically has only two Conv layers. In some top-performed SR networks (e.g., RCAN), there are even nested residual blocks. To see how serious this problem is, taking EDSR as an example, it has 32 residual blocks and each block has two Conv layers. If we do not prune the 2nd Conv layer in a residual block, it means half of the Conv layers are not  pruned. Namely, at best , we can only achieve 2 × theoretical acceleration (measured by FLOPs reduction).

Owing to the pruned index constraint problem, many ﬁlter pruning methods in image classiﬁcation simply do not prune the last Conv layer in residual blocks (Li et al., 2017; Wang et al., 2021), which can still deliver considerable speedup of practical interest. Nevertheless, this doing-nothing solution can barely translate to the image SR networks if we target a considerable speedup. The root cause is that image SR networks typically employ many more residual blocks, and each block usually has only two Conv layers. In some top-performing SR networks (e.g., RCAN), there are even nested residual blocks. Taking EDSR for a concrete example, it has 32 residual blocks and each block has two Conv layers. If the 2nd Conv layer in a residual block is spared from pruning, half of the Conv layers will not be pruned. In other words, at best , we can only achieve 2 × theoretical acceleration measured by FLOPs reduction.


Fig. 2 demonstrates that the performance of the parametric Copula-GP model critically depends on the match between the true probability density and the best mixture of parametric copula elements. When the parametric distribution matches the true distribution (Fig. 2A), our Copula-GP framework  predictably outperforms all non-parametric methods. Nonetheless, even when the exact reconstruction of the density is not possible (Figs. 2B-C), the mixtures of the copula models are still able to model the changes in tail dependencies, at least qualitatively. As a result, our method performs similarly to the neural-network based method (MINE) and still outperforms KSG-like methods.

Fig. 2 demonstrates that the performance of the parametric Copula-GP model critically depends on the match between the true probability density and the best mixture of parametric copula elements. When the parametric distribution matches the true distribution (e.g. Fig. 2A or Fig. A5), our Copula-GP framework provides unbiased estimates and predictably outperforms all non-parametric methods. Nonetheless, even when the exact reconstruction of the density is not possible (Figs. 2BC), the mixtures of the copula models are still able to model the changes in tail dependencies, at least qualitatively. In those challenging examples, our method performs similarly to the neural-network based method (MINE) and still outperforms KSG-like methods.

Instruction: Edit this paragraph for clarity and add a mention of Figure 5.


Examples Below are a few query words (Q) and their closest neighbours (N). Note the high structural similarity of the entire sentence, as well as the function of the word within it (Q1: last word of subject NP in a middle clause, Q2: possessed noun in sentence initial subject NP, Q3: head of relative clause of a direct object):

Examples Below are a few query words (Q) and their closest neighbours before (N) and after (NT) the transformation. Note the high structural similarity of the entire sentence, as well as the function of the word within it (Q1: last word of subject NP in a middle clause, Q2: possessed noun in sentence initial subject NP, Q3: head of relative clause of a direct object):


In experiment 1, we showed that the notch increases the pointing movement time in specific situations. Furthermore, when the notch is  between the targets, participants moved the cursor with two main strategies: (i) to move the cursor along the edge (along-strategy) and (ii) to avoid the notch (avoid-strategy). In experiment 2, we investigated which of the above strategies is preferable in the current specification that allows the cursor to enter the notch.

In Experiment 1, we showed that the notch increases the pointing movement time under specific scenarios. Further, we found that participants moved the cursor based on two main strategies when the notch is placed between the start area and the target: (i) to move the cursor along the edge (along-strategy) and (ii) to avoid the notch (avoid-strategy). In Experiment 2, we investigated which of the above strategies is preferable in the current specification that allows the cursor to enter the notch.

Instruction: Rewrite the second sentence. Replace some words for the better

Instruction: Make this paragraph more logical and precise.


We develop on the open-sourced simulator RecSim simulator ((Ie et al., 2019a)) which allows an agent to interact with simulated users by recommending a list of items. We have a base action set of 250 train items and 250 test items, and in each episode 20 items are given to the agent. It must recommend a list of size 6. We take user preference vectoras the state (MDP) and ground truth action representations from the environment. We incorporate CPR by boosting up the probability of  user clicking any item proportional to the  CPR. This simulates one of the scenarios whereuser preference model is inﬂuenced by the entire list. An optimal agent should identify the most common category in the available action set and try to recommend most items in its list from  category. This requires understanding the relation with the other candidate items from the same category. We train CDQN-based models to maximize the number of clicks in a user session.

We use RecSim (Ie et al., 2019a) to simulate user interactions and extend it to the listwise recommendation task. We have a base action set of 250 train and 250 test items, and 20 items are sampled as actions for the agent in each episode. The agent recommends a list-action of size six at each step. We assume a fully observable environment with the state as the user preference vector and the action representations as item characteristics. The objective implicitly incorporates CPR by boosting the probability of a user clicking any item proportional to the list CPR. The implicit CPR objective exempliﬁes realistic scenarios where the entire list inﬂuences user response. One way to optimize CPR is to identify the most common category in the available action set and recommend most items from that category. Such counting of categories requires relational reasoning over all items available in the action set. We train CDQN-based models to maximize the number of clicks in a user session.

Instruction: Rewrite the sentences, making them shorter and more connected.

Instruction: Rewrite the sentences of this paragraph for better readability and fitting to the academic style.


We evaluate AGILE against baselines from prior work in varying action space, that either assume a ﬁxed action set or work without the knowledge of the other available actions. For ablations, we keep the action set summarizer, but replace the  relational action features  with raw action representations to compute  action utility. Thearchitectures of all methods are visually compared in Appendix C.1. All methods share the same training framework (PPO or CDQN) depending on the environment.

We evaluate AGILE against baselines from prior work in varying action space, which either assume a ﬁxed action set or act independently of the other actions. We ablate the importance of relational action features by replacing them with the original action representations and compute the action set summary in different ways. The Appendix details the comparison (C.1) and visualization (Figure 17) of all baselines and ablations, hyperparameter-tuning (D.2,D.3) and network designs(C.3).

Instruction: Rewrite the last 2 sentences favoring "we" forms and explaining the paper structure more concise.


Recently, Ji et al. (2019) presented Action Genome, a new video dataset annotated by SGs. This dataset includes spatio-temporal SG annotations, where for each video, few individual frames were chosen and spatially annotated by SGs. Here, we use the Something-Something V2 (Goyal et al., 2017) dataset that is larger (200K vs. 10K videos) and more diverse since it includes basic human activities created by a large number of crowd workers. Finally, we propose the Action Graph representation, which we view as a temporal extension of SGs, and argue it is more natural for representing videos of actions.

Recently, Ji et al. (2019) presented Action Genome, a new video dataset annotated by SGs. This dataset includes spatio-temporal SG annotations, where for each video, few individual frames were chosen and spatially annotated by SGs. Here, we use the Something-Something V2 (Goyal et al., 2017) dataset that is larger (200K vs. 10K videos) and more diverse since it includes basic human activities created by a large number of crowd workers. Finally, we propose the Action Graph representation, which we view as a temporal extension of SGs.

Instruction: Remove the argument that Action Graph is a more natural representation.

Instruction: Remove the less important details in the last sentence.


We propose to apply a VIB module to reduce over-fitting when fine-tuning large-scale pre-trained language models on low-resource datasets. VIB  finds the simplest sentence embedding, predictive of the target labels, by removing task-irrelevant and task-redundant information. Our approach is model agnostic, simple to implement, and highly effective. Extensive experiments  show that our method substantially improves transfer performance in low-resource scenarios, including a 2.97 point gain on STS-B and a 2.03 point gain on MRPC. Furthermore, we demonstrate that our model results in a  better generalization to out-of-domain NLI datasets. Future work includes exploring incorporating VIB on multiple layers of pre-trained language models and using it to jointly learn relevant features and relevant layers.

We propose VIBERT, an effective model to reduce over-fitting when fine-tuning large-scale pre-trained language models on low-resource datasets. By leveraging a VIB objective, VIBERT finds the simplest sentence embedding, predictive of the target labels, while removing task-irrelevant and redundant information. Our approach is model agnostic, simple to implement, and highly effective. Extensive experiments and analyses show that our method substantially improves transfer performance in low-resource scenarios. We demonstrate our obtained sentence embeddings are robust to biases and our model results in a substantially better generalization to out-of-domain NLI datasets. Future work includes exploring incorporating VIB on multiple layers of pretrained language models and using it to jointly learn relevant features and relevant layers.


Color should be made less dominant and should not be used as the primary identifier for medication entries. While solid dull color was effective in indicating busy slots, using color fill for medica- tion entries was cluttering the designs. The amount of medicationidentification information which is visually present in the calendar entry should also be minimized. Medication labels, including name and dosage, tend to overflow the containing entry. Labels were a source of confusion as to which entry they referred to when multiple entries occupied the same cell. They should be abstracted from the overview and instead be made available as details on demand.

Color should be made less dominant and should not be used as the primary identifier for medication entries. While solid fill color was effective in indicating busy slots, using color fill for medica- tion entries was cluttering the designs. The amount of medication information shown (e.g., labels, including name and dosage) should also be minimized. Labels were a source of confusion as to which entry they referred to when multiple entries occupied the same cell. They should be abstracted from the overview and instead be made available as details on demand.

Instruction: Remove unnecessary details and explanations.

Instruction: I want to restate my third sentence.


First, we compare the proposed sampling method to several variants of the VAE such as the Wasserstein Autoencoder  (Tolstikhin et al., 2018), Regularized Autoencoders (Ghosh et al., 2020), a vampprior VAE  (Tomczak & Welling, 2018), a geometry-aware VAE  (Chadebec et al., 2020) and a simple

First, we compare the proposed sampling method to several variants of the VAE such as the Wasserstein Autoencoder (WAE) (Tolstikhin et al., 2018), Regularized Autoencoders (Ghosh et al., 2020) with either L2 decoder’s parameters regularization (RAE-L2), gradient penalty (RAE-GP), spectral normalization (RAE-SN) or simple L2 latent code regularization (RAE), a vamp-prior VAE (VAMP) (Tomczak & Welling, 2018), a geometry-aware VAE (RHVAE) (Chadebec et al., 2020) and a simple


Voxel transformer for 3D detection. VoTr [23] introduces a voxel-based transformer backbonethat performs self-attention on sparse voxels with the local  and  the dilated attention mechanisms. Our work improves VoTr by introducing the window-based attention and optimizing the sparseoperation. The recent SST [7] follows a single-stride design and the swin-transformer architecture,which performs well on small objects. Nevertheless, SST is implemented based on pillars. The single window size is not conducive to capturing multi-scale features, resulting in unsatisfactoryperformance on Vehicle when simultaneously detecting multiple categories. In comparison, our MsSVT can capture mixed-scale information to boost detection of objects of various scales.

Voxel transformer backbone in 3D detection. VoTr [20] introduces two kinds of sparse voxelattention, including local attention and extended attention. Each voxel serves as a query and attendswith the neighbor voxels. We optimize the sparse operation and introduce window attention, whichsignificantly improves efficiency and performance. The recent SST [6] adopts a single-stride designand swin-transformer structure, which performs well on small objects. However, SST is implemented based on a pillar. The single window size is not conducive to capturing multi-scale features, resultingin the low performance of vehicles when multiple categories are detected simultaneously. In contrast,our MsSVT can capture fine and global features and better performance on large and small objects.


Calendar entries are shown like in standard calendars: the height of rectangular entries indicates their duration,their color hue indicates their type, or category, as set by the user, and their name is conveyed with a label. In this design, we also represent medication entries with rectangles (or bars), whose vertical position and height indicates start and end of the allowed administration period for the medication. Medication entries have an embossed horizontal marker placed at some point along the bar to indicate the preferred administration period (at which point the reminder would trigger if programmed). Preferred administration time of a medication entry is shown with higher opacity and allowed administrative time with lower opacity. Color hue encodes the type of medication.

The height of rectangular entries indicates their duration, color is used to differentiate types or categories of entries (as set by the user), and their names are conveyed with textual labels. In this design, we also represent medication entries with rectangles (or bars), whose vertical position and height indicates start and end of the allowed administration period for the medication. Medication entries have an embossed horizontal marker placed at some point along the bar to indicate the planned administration time (at which point the reminder would trigger if programmed). Preferred administration time of a medication entry is shown with higher opacity and allowed administrative time with lower opacity. Color hue encodes the type of medication.

Instruction: Improve the English of this paragraph.

Instruction: Make the first sentence more concise and direct.


Large-scale pre-trained language models act as general-purpose feature extractors, but not all the features are relevant for a given target task.This can cause problems in low-resource scenarios, where fine-tuning such large-scale models often over-fits on the small training set. We propose to use the information bottleneck principle to improve generalization in this scenario. We apply the variational information bottleneck method  to remove task-irrelevant and redundant features from sentence embeddings during the fine-tuning of BERT. Evaluation on seven low-resource datasets for different tasks shows that our method significantly improves transfer learning in low-resource scenarios and obtains better generalization on 11 out ofout-of-domain textual entailment datasets.

While large-scale pretrained language models have obtained impressive results when fine-tuned on a wide variety of tasks, they still often suffer from overfitting in low-resource scenarios. Since such models are general-purpose feature extractors, many of these features are inevitably irrelevant for a given target task. We propose to use Variational Information Bottleneck (VIB) to suppress irrelevant features when fine-tuning on low-resource target tasks, and show that our method successfully reduces overfitting. Moreover, we show that our VIB model finds sentence representations that are more robust to biases in natural language inference datasets, and thereby obtains better generalization to out-of-domain datasets. Evaluation on seven low-resource datasets in different tasks shows that our method significantly improves transfer learning in low-resource scenarios, surpassing prior work. Moreover, it improves generalization on 13 out of 15 out-of-domain natural language inference benchmarks. Our code is publicly available in https://github.com/rabeehk/vibert .


In this paper, we propose tree-structured recurrent switching linear dynamical systems (TrSLDS) which is an extension of Linderman et al. (2017) rSLDS. The tree-structured stick breaking removes the dependence on the permutation of  the discrete latent states. The tree-structured stick breaking paradigm naturally lends itself to imposing a tree-structured hierarchical prior on the dynamics. The structure of the prior allows for a multi-scale view of the system; one can query at different levels of the trees to see different scales of the resolution. We also developed a fully Bayesian approach to learning the parameters of the model. The analysis of the Graf data suggests that the method can also be used to analyze neural data.

In this paper we propose tree-structured recurrent switching linear dynamical systems (TrSLDS) which is an extension of rSLDS (Linderman et al., 2017). The system relies on the use of treestructured stick-breaking to partition the space. The tree-structured stick-breaking paradigm naturally lends itself to imposing a hierarchical prior on the dynamics that respects the tree structure. This tree-structured prior allows for a multi-scale view of the system where one can query at different levels of the tree to see different scales of the resolution. We also developed a fully Bayesian sampler, which leverages the Pólya-Gamma augmentation, to learn the parameters of the model and infer latent states. The two synthetic experiments show that TrSLDS can recover a multi-scale view of the system, where the resolution of the system increase as we delve deeper into the tree. The analysis on the real neural data veriﬁes that TrSLDS can ﬁnd a multi-scale structure. A P ROOF OF T HEOREM Proof.


We use the CREATE environment (Jain et al., 2020) as a challenging environment with a large base action space and  unseen actions for evaluation. The task is to sequentiallyselect tools from a given toolbox and place them appropriately on the screen with the objective to  push the red ball towards the green goal. We deal with the hybrid action space with an auxiliary  network that takes the  state and action set summary as input, following Jain et al. We simulate the need of action relation learning by associating each tool (e.g. cannon) with an activator tool (e.g. ﬁre). A tool functions only if in contact with the right activator, otherwise the objects pass through it. Thus the tool choice must now consider the current environment state as well as whether its activators are available. We borrow the action representations from the prior work and add extra dimensions to accommodate one-hot vectors for the activator tools.

The CREATE environment (Jain et al., 2020) is a challenging physical reasoning benchmark with a large variety of tools as actions and also supports evaluation with unseen actions. The objective is to sequentially place tools to help push the red ball towards the green goal. An action is a hybrid of a discrete tool-selection from varying toolsets and a continuous ( x, y ) coordinate of tool-placement on the screen. An auxiliary policy network decides the tool-placement based on the effective state s (cid:48) as input, following Jain et al. To emphasize action relations, we augment the environment with special activator tools (e.g., ﬁre) that general tools (e.g., cannon) need in contact for being functional. Thus, a general tool can be useful only if its activator is also available. Action representations of general tools encode their physical behavior (Jain et al., 2020), while those of activator tools are one-hot vectors. We train AGILE and the auxiliary policy jointly with PPO.

Instruction: Rewrite the paragraph using more appropriate language.


To apply the concept of regular cell complexes to graphs, Bodnar et al. (2021a) define the concept of a cellular lifting map , a function f that transforms a graph to a regular cell complex such that two graphs G 1 , G 2 are isomorphic if and only if f ( G 1 ) , f ( G 2 ) are isomorphic. They prove that a class of lifting maps called skeleton preserving lifting maps together with CWL are at least as expressive as WL. Typically, such lifting maps create cells out of vertices, together with cells that encode other structures such as induced cycles or cliques. They define CW Networks which combine neural networks with cellular message passing, similar to graph neural networks with message passing.

To apply the concept of regular cell complexes to graphs, Bodnar et al. (2021a) define the concept of a cellular lifting map , a function f that transforms a graph to a regular cell complex such that two graphs G 1 , G 2 are isomorphic if and only if f ( G 1 ) , f ( G 2 ) are isomorphic. They prove that a class of lifting maps called skeleton preserving lifting maps together with CWL are at least as expressive as WL. Typically, such lifting maps create cells out of vertices, together with cells that encode other structures such as induced cycles or cliques. Figure 1 shows an example of this, the original graph (left) is turned into a cell complex (right) where the vertices are 0-dimensional cells, edges are 1-dimensional cells, and cycles are 2-dimensional cells (blue). Bodnar et al. (2021a) define CW Networks which combine neural networks with cellular message passing, similar to graph neural networks with message passing.


For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] (b) Did you describe the limitations of your work? [N/A] (c) Did you discuss any potential negative societal impacts of your work? [N/A]


HDNO. Speciﬁcally, a dialogue act in HDNO is seen as an option whereas each generated word from NLG becomes a primitive action. Accordingly, dialogue policy and NLG become the policy over option (i.e. high-level policy) and the intra-option policy (i.e. low-level policy) respectively. Distinguished from a conventional modular system, we additionally give a context to NLG to satisfy the  option framework. Moreover, since the primitive action space (i.e. a vocabulary) comprises a termination symbol, NLG can take over the responsibility of termination. For this reason, termination policy  is absorbed in the intra-option policy. HDNO is formally deﬁned in Deﬁnition 1.

HDNO. Speciﬁcally, a dialogue act in HDNO is seen as an option whereas each generated word from NLG is a primitive action. Accordingly, dialogue policy and NLG become the policy over option (i.e. high-level policy) and the intra-option policy (i.e. low-level policy) respectively. Distinguished from a conventional modular system, we additionally give a context to NLG to satisfy the conditions of the option framework. Moreover, since the primitive action space (i.e. a vocabulary) comprises a termination symbol, NLG can take over the responsibility of termination. For this reason, termination policy in the original option framework is absorbed into the intra-option policy. The formal deﬁnition of HDNO is shown in Deﬁnition 1.

Instruction: Rewrite some formulations to describe HDNO more as a state than a progress.

Instruction: Make the last sentence more direct. Give slightly more context for better readability.


We also remark recent work on domain shift while controlling from pixels Hansen & Wang (2021); Kostrikov et al. In these papers the authors assume that some pixels may change from an episode to an episode (e.g., red color becomes blue), but the underlying dynamics stay the same. Besides the episodic nature of the context change, this setting differs from ours on two fronts. First, controlling from pictures constitutes a POMDP problem, where the true states (positions, velocities, accelerations) are observed through a proxy (through pixels) and hence need to be inferred. Second, the underlying dynamics stay the same (Hansen & Wang, 2021; Kostrikov et al., 2020) and only observations change. Our case is the opposite: the underlying a dynamics change, but the observation  function stays the same. In future work we aim to extend our methods to control from pixels. Continual (lifelong) RL mainly adopts a context incremental setting, where the agent is exposed to a sequence of contexts (Delange et al., 2021). While the agent’s goal is still to adapt efﬁciently to the unseen contexts, the emphasis is on overcoming catastrophic forgetting, i.e., maintaining a good performance on old contexts while improving performance on the current one (Rolnick et al., 2019; Riemer et al., 2019).

We also remark recent work on domain shift while controlling from pixels Hansen & Wang (2021); Kostrikov et al. In these papers the authors assume that some pixels may change from an episode to an episode (e.g., red color becomes blue), but the underlying dynamics stay the same. Besides the episodic nature of the context change, this setting differs from ours on two fronts. First, controlling from pictures constitutes a POMDP problem, where the true states (positions, velocities, accelerations) are observed through a proxy (through pixels) and hence need to be inferred. Second, the underlying dynamics stay the same (Hansen & Wang, 2021; Kostrikov et al., 2020) and only observations change. Our case is the opposite: the underlying dynamics change, but the observation a function stays the same. In future work we aim to extend our methods to control from pixels. We also note the work by Ball et al. (2021), who proposed to learn a contextual policy by augmenting an ofﬂine world model. In the online setting the algorithm had to learn only the current context thus improving efﬁciency of the learning procedure while delivering good performance. Continual (lifelong) RL mainly adopts a context incremental setting, where the agent is exposed to a sequence of contexts (Delange et al., 2021). While the agent’s goal is still to adapt efﬁciently to the unseen contexts, the emphasis is on overcoming catastrophic forgetting, i.e., maintaining a good performance on old contexts while improving performance on the current one (Rolnick et al., 2019; Riemer et al., 2019).


We presented Dyn-GFN, a method for Bayesian causal discovery from dynamics. In low dimensions we found that Dyn-GFN is able to better model the distribution over possible explanatory structures than baseline methods. As a proof of concept, we presented an example of learning the distributionover likely explanatory graphs from single-cell transcriptomic data where there are many possiblegraphs showing Dyn-GFN can better model the uncertainty over possible explanations of this datarather than capturing a single one.

We presented Dyn-GFN, a method for Bayesian causal discovery from dynamics. In low dimensions we found that Dyn-GFN is able to better model the distribution over possible explanatory structures than baseline methods. As a proof of concept, we presented an example of learning the distribution over likely explanatory graphs from single-cell transcriptomic data where there are many possible graphs showing Dyn-GFN can better model the uncertainty over possible explanations of this data rather than capturing a single explanation.  Limitations Although we have demonstrated a degree of efficacy when using Dyn-GFN for Bayesian causal discovery with observational data, a key limitation of Dyn-GFN is scaling to larger systems. To effectively model P ( G, θ, D ) , Dyn-GFN needs to search over an environment state space of possible graphs.


Representation-based methods, e . g ., BNN (Johansson et al., 2016) and CFR (Uri et al., 2017), balance the distributions in the latent space. Liuyi et al. and Hassanpour & Greiner (2020) further augment CFR with local similarity and non-confounding factors, respectively. Kallus (2020) and Yoon et al. (2018) propose to balance the distributions of representations with adversarial training. Representation learning has been the primary approach to mitigate the treatment selection bias, owing to its  avoidance of the high variance issue and the suitability for large-scale scenarios.

Begining with BNN (Johansson et al., 2016) and CFR (Shalit et al., 2017), representation-based methods minimize the group discrepancy in the latent space. Liuyi et al. and Hassanpour & Greiner (2020) further augment CFR with local similarity and non-confounding factors, respectively. Kallus (2020) and Yoon et al. (2018) propose to balance the distributions of representations with adversarial training. Due to its scalability and avoidance of the high variance issue, representationbased methods have been predominant for handling the treatment selection bias.

Instruction: Make the benefit clearer.

Instruction: Reorder the elements in sentences to improve the readability.


Mahapatra & Rajan (2020) presented Exact Pareto Optimal (EPO), an MOO optimization method that can converge to a desired ray in loss space. Given a preference ray r , EPO search for an exact Pareto optimal solution, i.e. a solution that is (i) Pareto optimal, and; (ii) Lies on the intersect of the Pareto front and the preference vector r . The EPO method balances two goals: Finding a descent direction  and getting to the desired ray. EPO searches for a point in the convex hull of the gradients, known by Désidéri (2012) to include descent directions, that has  maximal angle with a vector d bal which pulls the point to the desired ray. EPO combines gradient descent and controlled ascent enabling it to reach an exact Pareto optimal solution if one exists, or the closest Pareto optimal solution.

Convergence to the desired ray in loss space can be achieved using Exact Pareto Optimal (EPO) (Mahapatra & Rajan, 2020). To ﬁnd the intersection of the Pareto front with a given preference ray r , EPO balances two goals: Finding a descent direction towards the Pareto front and approaching the desired ray. EPO searches for a point in the convex hull of the gradients, known by Désidéri (2012) to include descent directions, that has a maximal angle with a vector d bal which pulls the point to the desired ray. EPO combines gradient descent and controlled ascent enabling it to reach an exact Pareto optimal solution if one exists, or the closest Pareto optimal solution.

Instruction: Exclude unnecessary ideas.

Instruction: Rewrite the first half of this paragraph to make it clearer and easier to read.


Branch Decider. Since the network context is not known during deployment, this creates the needfor a branch decider module. The branch decider reuses clusters labels from the training stage for a K Nearest Neighbours [45] classiﬁcation. The light-weight distance based metric is used to classify the inference-time observation into one of the training groupings, and thereby executing the corresponding branch’s symbolic policy. Figure 3 illustrates our complete training and deployment techniques.

Branch Decider: Since the network context is not known during deployment, one needs a branch decider module. The branch decider reuses cluster labels from the training stage for a K Nearest Neighbors [51] classification. The light-weight distance-based metric is used to classify the inference-time observation into one of the training groupings and thereby executing the corresponding branch’s symbolic policy. Figure 3 illustrates our complete training and deployment techniques.

Instruction: Rewrite some formulations, preferring shorter ones and fix typos.

Instruction: Improve the english of this text.


Metric function " #$ - " #$ - ! ! in a ﬁne-grained classiﬁcation setting). As a result, understanding and addressing the domain shift problem for few-shot classiﬁcation is of great interest.

Metric function " #$ - " #$ - ! ! the difﬁculty to construct large training datasets for rare classes (e.g., , recognizing rare bird species in a ﬁne-grained classiﬁcation setting). As a result, understanding and addressing the domain shift problem for few-shot classiﬁcation is of great interest.


• Colored-and-gray-MNIST: we train multi-modal DNNs using SGD with the momentum coefﬁcient of 0.9 and a batch size of 128. We sample uniformly 20 learning rates at random from the interval [10 − 5 , 1] on a logarithmic scale. We train each model four times while varying random seeds. In total, we train 80 models. ModelNet40: we use SGD without momentum and use minibatches of size 8. Werandomly select nine learning rates from 10 − 3 to 1 . We train each model three times and end up with 27 models. • NVGesture: we use a batch size of four, SGD with momentum of 0.9, and uniformly samplelearning rates at random from the interval [10 − 4 , 10 − 1 . 5 ] on a logarithmic scale. We train each model three times, resulting in 60 models in total.

• Colored-and-gray-MNIST: we train multi-modal DNNs using SGD with the momentum coefﬁcient of 0.9 and a batch size of 128. We sample 20 learning rates at random from the interval [10 − 5 , 1] on a logarithmic scale. We train the model four times using each of the learning rate and random initialization of the parameters. In total, we train 80 models. ModelNet40: we use SGD without momentum and use minibatches of eight examples. We select nine learning rates from 10 − 3 to 1 and train model using each learning rate for three times. This ends up with 27 models. • NVGesture: we use a batch size of four, SGD with momentum of 0.9, and uniformly samplelearning rates from the interval [10 − 4 , 10 − 1 . 5 ] on a logarithmic scale. We train the model three times using each learning rate, resulting in 60 models in total.

Instruction: Rewrite. Try to fix it when there are some missing words.


Until convergence 25: return θ 26: end function then we have successfully found a non-saturating CBF.

Until convergence 25: return θ 26: end function It is a measure of the best-case saturation at a given state x . When L ( θ, x ) ≤ 0 , then no saturation occurs at x ; when L ( θ, x ) > 0 , it measures how severe the saturation is. Thus, our min-max problem (Eqn. 4) is to minimize the worst best-case saturation over the boundary.


We did not use Position and start from experiment 1 in experiment 2, and  always placed the notch between the start area and the target. Instead, we added the condition of cursor movement strategy ( Strategy ). Strategy = along means moving the cursor along the top edge of the screen (Figure 7 (i)). Strategy = avoid means moving the cursor by avoiding the notch (Figure 7 (ii)). The target was a rectangle, with a height of 6 mm  and a width ( W ) of 6 and 23 mm. The interval ( I ) between the notch and target was 0, 12, ∞ mm. To avoid increasing the workload on the participants, we chose the characteristic conditions from experiment 1 for W and I , and  used almost equivalent values. The notch size and A were the same as  in experiment 1.

We did not use Position and Start from Experiment 1 in Experiment 2, and we always placed the notch between the start area and the target. Instead, we added the condition of cursor movement strategy ( Strategy ). Strategy = along means moving the cursor along the top edge of the screen (Figure 7 (i)). Strategy = avoid means moving the cursor by avoiding the notch (Figure 7 (ii)). The target was a rectangle with a height of 6 mm (22 pixels) and a width ( W ) of 6 and 23 mm (22 and 84 pixels). The interval ( I ) between the notch and target was 0, 12, ∞ mm (0, 44, ∞ pixels). We chose the characteristic conditions from Experiment 1 for W and I to avoid increasing the workload on the participants, and we used almost equivalent values. The notch size and A were the same as those in Experiment 1.


First, many models have high | d util | , especially when trained to use two distinct modalities. This conﬁrms that the standard multi-modal learning process encourages the model to rely on one modality and ignore the other one, which is consistent with our hypothesis. We make this observation across all tasks, conﬁrming that the conventional multi-modal learning process is greedy regardless of network architectures and tasks.

First, many models have high | d util | . This conﬁrms that the multi-modal learning process encourages the model to rely on one modality and ignore the other one, which is consistent with our hypothesis. We make this observation across all tasks, conﬁrming that the conventional multi-modal learning process is greedy regardless of network architectures and tasks.

Instruction: Remove the second part of the first sentence

Instruction: Exclude unnecessary details.


To observe the consequence of having a discriminator trained on empirical distributions, we assume that the reward is represented with a optimal discriminator such that r ( s, a ) = log E ( s,a ) D ( s,a ) . As a result, objective (9) becomes:

To observe the consequence of having a discriminator trained on empirical distributions, we assume that the reward is represented with an optimal discriminator such that r ( s, a ) = log E ( s,a ) D ( s,a ) . As a result of applying this to objective (10), it becomes:

Instruction: Be more specific when talking about the result.

Instruction: Improve this text to fit a more academic style.


ConstantResolution  To tackle this challenge, we propose M ulti-scale M asked autoencoders for learning the hierarchicalrepresentations of point clouds via self-supervised pre-training, termed as Point-M2AE. We representa point cloud as a set of point tokens depicting different spatial local regions, and inherit MAE’spipeline to first encode visible point tokens and then reconstruct the masked 3D coordinates. Differentfrom 2D images, masked autoencoding for 3D point clouds has three characteristics to be  considered. Firstly, it is critical to understand the relations between local parts and the overall 3D shapes, whichhave strong geometric and semantic dependence. As examples, the network can recognize an airplanestarting from its wing, or segment the wing’s part from the airplane’s global feature. Therefore, weregard the standard transformer with the plain encoder and decoder is sub-optimal for capturingsuch local-global spatial relations in 3D, which directly downsamples the input into a low-resolutionrepresentation as shown in Figure 1 (Top). We modify both the encoder and decoder into multistage hierarchies for progressively encoding multi-scale features of point clouds, constructing anasymmetric U-Net [34] like architecture in Figure 1 (Bottom). In detail, the shallower stages of theencoder contain a larger number of point tokens to focus on local patterns, while the deeper stagesmerge spatially adjacent tokens to acquire global understanding. Secondly, as  Point-M2AE encodesmulti-scale point clouds unlike the single-scale 2D images, the unmasked visible regions are requiredto be  block-wise within one scale and consistent across scales, which are respectively for reservingmore complete local geometries and ensuring coherent feature learning for the network. For this, weintroduce a multi-scale masking strategy, which generates random masks at the final scale with ahigh ratio (e.g., 80%), and back-projects the unmasked positions to all preceding scales. Thirdly, tobetter capture the  fine-grained 3D geometries, we  adopt a local spatial self-attention mechanism withincreasing attention scopes for point tokens at different stages in the encoder, which refocus eachtoken within neighboring detailed structures.Also, we utilize skip connections to complement thedecoder with fine-grained information from the corresponding stages of the encoder.

ConstantResolution top. Despite its superiority on grid-based 2D images, we ask the question: can MAE-style masked autoencoding be adapted to irregular point clouds as a powerful 3D representation learner? To tackle this challenge, we propose M ulti-scale M asked autoencoders for learning the hierarchical representations of point clouds via self-supervised pre-training, termed as Point-M2AE. We represent a point cloud as a set of point tokens depicting different spatial local regions, and inherit MAE’s pipeline to first encode visible point tokens and then reconstruct the masked 3D coordinates. Different from 2D images, masked autoencoding for 3D point clouds has three characteristics to be specially considered. Firstly, it is critical to understand the relations between local parts and the overall 3D shapes, which have strong geometric and semantic dependence. As examples, the network can recognize an airplane starting from its wing, or segment the wing’s part from the airplane’s global feature. Therefore, we regard the standard transformer with the plain encoder and decoder is sub-optimal for capturing such local-global spatial relations in 3D, which directly downsamples the input into a low-resolution representation as shown in Figure 1 (Top). We modify both the encoder and decoder into multi-stage hierarchies for progressively encoding multi-scale features of point clouds, constructing an asymmetric U-Net [41] like architecture in Figure 1 (Bottom). Secondly, as our Point-M2AE encodes multi-scale point clouds unlike the single-scale 2D images, the unmasked visible regions are required to be both block-wise within one scale and consistent across scales, which are respectively for reserving complete local geometries and ensuring coherent feature learning for the network. For this, we introduce a multi-scale masking strategy, which generates random masks at the final scale with a high ratio (e.g., 80%), and back-projects the unmasked positions to all preceding scales. Thirdly, to better reconstruct 3D geometries from a local-to-global perspective, we utilize skip connections to complement the decoder with fine-grained information from the corresponding stages of the encoder. During fine-tuning on downstream tasks, we also adopt a local spatial self-attention mechanism with increasing attention scopes for point tokens at different stages of the encoder, which refocus each token within neighboring detailed structures.


L triplet → 0 as dist ( V A ,V P ) dist ( V A ,V N ) → 0 , as expected. The triplet objective is optimized end-to-end using the Adam optimizer (Kingma & Ba, 2015), with mini-batches of size 500. We train forepochs with a mini-batch of size [-
 A large enough mini-batch is necessary to ﬁnd challenging negative examples.-] , and take the last model as the ﬁnal syntactic extractor. During training, the gradient backpropagates through the pair vectors to the parameters f of the Siamese model, to get representations of individual words that are similar for corresponding words in equivalent sentences.

L triplet → 0 as dist ( V A ,V P ) dist ( V A ,V N ) → 0 , as expected. The triplet objective is optimized end-to-end using the Adam optimizer (Kingma & Ba, 2015). We train for 5 epochs with a mini-batch of size [-
 A large enough mini-batch is necessary to ﬁnd challenging negative examples.-] 500 6 , and take the last model as the ﬁnal syntactic extractor. During training, the gradient backpropagates through the pair vectors to the parameters f of the Siamese model, to get representations of individual words that are similar for corresponding words in equivalent sentences. We note that we do not back-propagate the gradient to the contextualized vectors: we keep them intact, and only adjust the learned transformation.


With the proposed spectral-wavelet GDN, we further propose a graph autoencoder (GAE) framework that resembles the symmetric fashion of architectures (Noh et al., 2015). We then evaluate the effectiveness of the proposed GAE framework with two popular and important tasks: unsupervised graph-level representation (Sun et al., 2020) and social recommendation (Jamali & Ester, 2010). In the ﬁrst task, the proposed GAE outperforms the state-of-the-arts on graph classiﬁcation in an unsupervised fashion, along with a signiﬁcant improvement on running time. In the second task, the performance of our proposed GAE is on par with the state-of-the-arts on the recommendation accuracy; at the meantime, the proposed GAE demonstrates strong robustness against rating noises and achieves the best recommendation diversiﬁcation (Ziegler et al., 2005).

With the proposed spectral-wavelet GDN, we further propose a graph autoencoder (GAE) framework that resembles the symmetric fashion of architectures (Noh et al., 2015). We then evaluate the effectiveness of the proposed GAE framework with three popular and important tasks: unsupervised graph-level representation (Sun et al., 2020), social recommendation (Jamali & Ester, 2010) and graph generation. In the ﬁrst task, the proposed GAE outperforms the state-of-the-arts on graph classiﬁcation in an unsupervised fashion, along with a signiﬁcant improvement on running time. In the second task, the performance of our proposed GAE is on par with the state-of-the-arts on the recommendation accuracy; at the meantime, the proposed GAE demonstrates strong robustness against rating noises and achieves the best recommendation diversiﬁcation (Ziegler et al., 2005). In the third task, our proposed GDN can enhance the generation performance of popular variational autoencoder frameworks including VGAE (Kipf & Welling, 2016) and Graphite (Grover et al., 2019).


Untargeted Attack Untargeted attack aims to generate adversarial examples that would be misclassiﬁed by the attacked model into any category different from the ground truth one. The overall results are shown in Table 1. Our method is competitive with previous attack methods in terms of adversarial perturbation and success rate, but our query number is reduced.

Untargeted Attack Untargeted attack aims to generate adversarial examples that would be misclassiﬁed by the attacked model into any category different from the ground truth one. The overall results are shown in Table 1, in which, the Meta transfer denotes that meta attacker trained on one dataset is used to attack target models on another dataset and Meta guided denotes using the output of meta attacker to guide the update of original Zoo method. Our method is competitive with baselines in terms of adversarial perturbation and success rate, but our query number is reduced.


Predict 3D positions With 3D spatial positional encoding and pair representation, the model can learn a good 3D representation. However, it still lacks the ability to directly output coordinates, which is essential in 3D spatial tasks. To this end, we introduce an SE(3)-equivariance head to predict the delta positions based on  pair representation, denoted as

Predict 3D positions With 3D spatial positional encoding and pair representation, the model can learn a good 3D representation. However, it still lacks the ability to directly output coordinates, which is essential in 3D spatial tasks. To this end, we introduce an SE(3)-equivariant head to predict the delta positions based on SE(3)-invariant pair representation and equivariant input x i − x j , denoted as


We examine the performance of AlgebraNet versions of ResNet-50 He et al. and MobileNetv1 Howard et al. (2017) on the ImageNet Russakovsky et al. (2015) dataset. We use a width multiplier on the channels to adjust model capacity. For all experiments we use SGD with momentum of 0 . 9 .

We examine the performance of AlgebraNet versions of ResNet-50 (He et al., 2016) and MobileNetv1 (Howard et al., 2017) on the ImageNet (Russakovsky et al., 2015) dataset. We use a width multiplier on the channels to adjust model capacity. For all experiments we use SGD with momentum of 0 . 9 .

Instruction: Review this paragraph.