Add files using upload-large-folder tool

parse/train/BkLhzHtlg/BkLhzHtlg.md

@@ -0,0 +1,252 @@
+# LEARNING RECURRENT REPRESENTATIONS FORHIERARCHICAL BEHAVIOR MODELING
+
+Eyrun Eyjolfsdottir1, Kristin Branson2, Yisong $\mathbf { Y u e ^ { 1 } }$ , & Pietro Perona1 1California Institute of Technology, 2Janelia Research Campus HHMI
+
+# ABSTRACT
+
+We propose a framework for detecting action patterns from motion sequences and modeling the sensory-motor relationship of animals, using a generative recurrent neural network. The network has a discriminative part (classifying actions) and a generative part (predicting motion), whose recurrent cells are laterally connected, allowing higher levels of the network to represent high level behavioral phenomena. We test our framework on two types of tracking data, fruit fly behavior and online handwriting. Our results show that 1) taking advantage of unlabeled sequences, by predicting future motion, significantly improves action detection performance when training labels are scarce, 2) the network learns to represent high level phenomena such as writer identity and fly gender, without supervision, and 3) simulated motion trajectories, generated by treating motion prediction as input to the network, look realistic and may be used to qualitatively evaluate whether the model has learnt generative control rules.
+
+# 1 INTRODUCTION
+
+Behavioral scientists strive to decode the functional relationship between sensory input and motor output of the brain (Tinbergen, 1963; Moore, 2002). In particular, ethologists study the natural behavior of animals while neuroscientists and psychologists study behavior in a controlled environment, manipulating neural activations and environmental stimuli. These studies require quantitative measurements of behavior to discover correlations or causal relationships between behaviors over time or between behavior and stimuli; automating this process allows for more objective and precise measurements, and significantly increased throughput (Dell et al., 2014; Anderson & Perona, 2014). Many industries are also concerned with automatic measurement and prediction of human behavior, for applications such as surveillance, assisted living, sports analytics, and self driving vehicles.
+
+Behavior is complex and may be perceived at different time-scales of resolution: position, trajectory, action, activity. While position and trajectory are geometrical notions, action and activity are semantic in nature. The analysis of behavior may therefore be divided into two steps: (a) detection and tracking, where the pose of the body over time is estimated, and (b) action/activity detection and classification, where motion is segmented into meaningful intervals, each one of which is associated with a goal or a purpose. Our work focuses on going from (a) to (b), that is to detect and classify actions from motion trajectories. We use data for which tracking and pose estimation is relatively simple, which lets us focus on modeling the temporal dynamics of pose trajectories without worrying about errors stemming from low level feature extraction.
+
+Supervised learning is a powerful tool for learning action classifiers from expert-labeled examples (Jhuang et al., 2010; Burgos-Artizzu et al., 2012; Kabra et al., 2013; Eyjolfsdottir et al., 2014). However, it has two drawbacks. First, it requires a lot of training labels which involves time consuming and painstaking annotation. Second, behavior measurement is limited to actions that a human can perceive and believes to be important. We propose a framework that takes advantage of both labeled and unlabeled sequences; it simultaneously learns to predict future motion and detect actions, allowing the system to learn from fewer expert labels and discover unbiased behavior representations.
+
+The framework models the sensory-motor relationship of an agent, predicting motion based on its sensory input and motion history. It can be used to simulate an agent by iteratively feeding motion predictions as input to the network and updating sensory inputs accordingly. A model that can simulate realistic behavior has learnt to emulate the generative control laws underlying behavior, which could be a useful tool for behavior analysis (Simon, 1996; Braitenberg, 1984).
+
+Our model is constructed with the goal that it will learn to represent and discover behaviors at different semantic scales, offering an unbiased way of measuring behavior with minimal human input. Recent work by Berman et al. (2014) and Wiltschko et al. (2015) shows promising results towards unsupervised behavior representation. Compared to their work our framework offers three advantages. Our model learns a hierarchical embedding of behavior, can be trained semi-supervised to learn specific behaviors of interest, and our sensory-motor representation enables the model to learn interactive behavior of an agent with other agents and with its environment.
+
+Our experiments focus mainly on the behavior of fruit flies, Drosophila Melanogaster, a popular model organism for the study of behavior (Siwicki & Kravitz, 2009). To explore the generality of our approach we also test our model on online handwriting data, an interesting human behavior that produces two dimensional trajectories.
+
+To summarize our contributions:
+
+1) We propose a framework that simultaneously models the sensory-motor relationship of an agent and classifies its actions, and can be trained with partially labeled sequences.   
+2) We show that motion prediction is a good auxiliary task for action classification, especially when training labels are scarce.   
+3) We show that simulated motion trajectories resemble trajectories from the data domain and can be manipulated by activating discriminative cell units.   
+4) We show that the network learns to represent high level information, such as gender or identity, at higher levels of the network and low level information, such as velocity, at lower levels.   
+5) We test our framework on the spontaneous and sporadic behavior of fruit flies, and the intentional and structured behavior of handwriting.
+
+# 2 BACKGROUND
+
+Hidden Markov models (HMMs) have been extensively used for sequence classification. The motivating assumption for HMMs is that there exists a process that transitions with some probability between discrete states, each of which emits observations according to some distribution, and the objective is to learn these functions given a sequence of observations and states. This model is limited in that its transition functions are linear, state space is discrete, and emission distribution is generally assumed to be Gaussian, although generalizations of the model that fall under the category of dynamic Bayesian networks are more expressive (Murphy, 2002).
+
+Recurrent neural networks (RNNs) have recently been shown to be extremely successful in classifying time series data, especially with the popularization of long short term memory cells (Hochreiter & Schmidhuber, 1997), in applications such as speech recognition (Graves et al., 2013). RNNs have also been used for generative sequence prediction of handwriting (Graves, 2013) as well as speech synthesis (Chung et al., 2015).
+
+Imitation learning involves learning to map a state to an action, from demonstrated sequences of actions. This is a supervised learning technique which, when implemented as an RNN, can be trained via backpropagation using action-error computed at every time step. The problem with this approach is that the domain of states that an agent is trained on consists only of states that the demonstrators encounter, and when an agent makes a mistake it finds itself in a situation never experienced during training. Reinforcement learning handles this by letting an agent explore the domain using an action policy, and updating the policy based on a goal-specific penalty or reward which may be obtained after taking several actions. This exploration can be extremely expensive, and therefore it is common to precede reinforcement learning with imitation learning to start the agent off with a reasonable policy. This strategy is used in (Mnih et al., 2015) where an agent is trained to play Atari games, and in (Silver et al., 2016) for mastering the game of GO.
+
+Autoencoders (Rumenlhart et al., 1986) have been used in semi-supervised classification to pretrain a network on an auxiliary task, such as denoising, to prevent overfitting on a small number of labeled data (Baldi, 2012). Recent work in this area (Rasmus et al., 2015) proposes to train on the primary and auxiliary task concurrently and using lateral connections (Valpola, 2015) between encoding and decoding layers to allow higher layers of the network to focus on high level features.
+
+Our framework takes inspiration from each of the works described here.
+
+# 3 MODEL
+
+Our model is a recurrent neural network, with long short term memory, that simultaneously classifies actions and predicts future motion of agents (insects, animals, and humans). Rather than actions being a function of the recurrent state, as is common practice, our model embeds actions in recurrent state units. This way the recurrent function encodes action transition probabilities and motion prediction is a direct function of actions, similar to an HMM. The network takes as input an agent’s motion and sensory input at every time step, and outputs the agent’s next move according to a policy, which is effectively learnt via imitation learning. Similar to autoencoders, our model has a discriminative path, used to embed high level information, and a generative path used to reconstruct the input domain, in our case filling in the future motion. Each discriminative recurrent cell is fully connected with its corresponding generative cell, allowing higher level states to represent higher level information, similar to the idea of Ladder networks (Valpola, 2015).
+
+![](images/1518169447b0a1f01f97c62b8a104d7d33c490630ecb6c985320dcffc79d8265.jpg)  
+Figure 1: Left: A 3D depiction of our network unrolled for 3 timesteps. The highlighted cells show the path from an input through a classification cell to a motion prediction output. During training, motion prediction loss $\mathcal { L } _ { x }$ is computed at every timestep, and classification loss $\mathcal { L } _ { y }$ is computed only at frames for which labels are provided. The diagonal connections between discriminative and generative cells enable higher levels of the network to represent high level information. Vector $v$ represents agent’s sensory input, $_ x$ its motion, $h$ its internal state, and $_ y$ labeled actions. Right: A zoom in on the blue and green cells showing the recurrent state (horizontal arrows) and inputs to the recurrent cell function $f$ . Merging of arrows represents vector concatenation, and branching vector duplication.
+
+# 3.1 ARCHITECTURE
+
+The model can be thought of as two parallel recurrent networks: The discriminative network takes as input an agent’s motion, $x$ , and environmental sensory input, $v$ , and propagates them up through its hidden states which encode high level information, including action labels, $y$ . The generative network decodes the states of the discriminative network, propagating information down to predict the agent’s motion at the next time step, $\hat { x }$ . The two networks have the same number of layers and are connected diagonally at each layer such that the information encoded in the hidden units of the discriminative network is propagated to the corresponding layer of the generative network at the next time step. Intuitively, these can be thought of as skip connections or “shortcuts” which let low level motion information propagate directly through lower levels of the network, leaving higher levels of the network free to represent high level phenomena, such as goals or individual characteristics. Our experiments confirm this intuition. The model can be trained without any action labels, in which case the hidden state may be used to discover high level information about the data, or with action labels for a subset of the data, in which case each action is assigned to a hidden state unit and will thus contribute to subsequent motion prediction and action classification.
+
+The flow of information through the network and the cost associated with its classification and prediction is expressed by the following equations:
+
+<table><tr><td>Discriminative</td><td>Generative</td></tr><tr><td>h=f（[xi,Ui],h²-1)</td><td>h+1=f(h,h）</td></tr><tr><td>h²=f(h-1,h²-1)</td><td>i= h+1=f([hi+1,h&#x27;],h） +1 T Cx=</td></tr><tr><td>i = (h²(1: N) +1)/2</td><td>xi+1=g(hi+1) C = λCy +(1-λ)Cx</td></tr></table>
+
+where $f$ is a recurrent cell function, $g$ is a transformation, $\mathcal { L } _ { y }$ computes classification loss (on frames for which labels are provided) and $\mathcal { L } _ { x }$ computes motion prediction loss. The total cost, $C$ , combines the misclassification cost, $C _ { y }$ , and misprediction cost, $C _ { x }$ , using $\lambda$ to trade off the two. $N$ is the number of labeled action classes, $L$ the number of levels, $T$ the number of frames, $l$ is the layer index and $i$ the frame index. The first $N$ units of state $h ^ { L }$ are forced to be classification units, they are scaled from [-1 1] to [0 1] (assuming $f$ ’s activation function is tanh) and assigned to $\hat { y }$ .
+
+The model is presented as part of a general framework where $f , g$ , and number of levels/units are architectural choices to be optimized for each dataset. For our experiments we found that 2-3 levels of recurrent cells with 100-200 units worked well, with $f$ as a gated recurrent unit (GRU) cell (Cho et al., 2014) and $g$ as linear transformation. The choice of loss functions depends on the target type; sigmoid cross entropy for multitask classification (where actions can co-occur), softmax cross entropy for multiclass classification (where actions are mutually exclusive), and sum of squared differences for regression (where outputs are real valued). The optimal value for $\lambda$ depends both on the output domain of $\mathcal { L } _ { y }$ and $\mathcal { L } _ { x }$ and whether the primary goal is classification or simulation. Data-specific model- and training parameters are described in Section 5 and further training details are discussed in supplementary material1.
+
+# 3.2 MULTIMODAL PREDICTION
+
+Evidence suggests that animal behavior is nondeterministic (Roberts et al., 2016); thus, motion prediction may be better represented as a probability distribution than a function. When future motion is multimodal, the best regression model will pick the average motion of the different modes which may not lie within any of the actual modes (visualized in supplementary material). This observation has been made by others in the context of modeling real-valued sequences with RNNs, (Graves, 2013) model the output of an RNN as a Gaussian mixture model and (Chung et al., 2015) additionally model the hidden recurrent states as random variables. We take a nonparametric approach, making no assumption about the shape of the distribution. We discretize motion into bins and treat the task of predicting future motion as independent multiclass classification problems for each motion feature, which results in a probability distribution over all bins for each dimension. More concretely, each dimension of $x$ is assigned $n$ bins and the target for $\hat { x } _ { i + 1 }$ becomes the binned version of $x _ { i + 1 }$ , denoted as $\tilde { x } _ { i + 1 }$ , which has exactly one nonzero entry for each dimension of $x$ . The prediction $\hat { x } _ { i + 1 }$ then becomes a discrete distribution over the bins for each feature dimension and the motion prediction loss becomes $\begin{array} { r } { \mathcal { L } _ { x } ( x _ { i + 1 } , \hat { x } _ { i + 1 } ) = \sum _ { d } ( \mathrm { c r o s s e n t r o p y } ( \tilde { x } _ { i + 1 } , \hat { x } _ { i + 1 } ) ) } \end{array}$ , as opposed to the Euclidean distance in the case when $x$ is a real valued vector. The number of bins determines the granularity of the motor control; a greater number of bins means more precise motion control but is also more expensive to train.
+
+# 3.3 SIMULATION
+
+Given a model that can predict an agent’s future motion from its current state, a virtual agent can be simulated by iteratively feeding predicted motion $\hat { x } _ { i + 1 }$ as input $x _ { i + 1 }$ to the network. We pick a bin by sampling from the distribution given by $\hat { x } _ { i + 1 }$ and assign a real value to $x _ { i + 1 }$ by sampling uniformly from the selected bin. An agent’s perception of the environment depends on the agent’s location, and therefore sensory features $v _ { i + 1 }$ must be updated for each forward simulation step to correspond to the agent’s perspective at time $i + 1$ . When simulating multiple agents that interact with one another, each agent is moved according to its $x _ { i + 1 }$ and then $v _ { i + 1 }$ is computed for each agent based on the new configuration of all agents.
+
+# 4 DATA
+
+Our framework is agent centric, it models the behavior of each agent individually based on how it moves and senses its surroundings, including other agents. It is applicable to any data that can be represented in terms of motor control (e.g. joystick controller) and sensory input that captures context from the environment (e.g. 1st person camera). We test our model on two types of data, fly behavior and online handwriting. Both can be thought of as a type of behavior represented in the form of trajectories, but the two are complementary. First, flies behave spontaneously, performing actions of interest sporadically and in response to their environment, while handwritten text is intensional and highly structured. Second, handwriting varies significantly between different writers in terms of size, speed, slant, and proportions, while inter-fly variation is relatively small. We use 4 datasets for our experiments (listed below) with the aim to answer the following questions: 1) does motion prediction improve action classification, 2) can the model generate realistic simulations (does it learn the sensory-motor control), and 3) can the model discover novel behavioral phenomena?
+
+Fly-vs-fly (Eyjolfsdottir et al., 2014) contains pairs of fruit flies engaging in 10 labeled courtshipand aggressive behaviors. We include this dataset in our experiments to see how our model compares with our previous action detection work which relies on handcrafted window features.
+
+FlyBowl is a video of 10 male and 10 female fruit flies interacting and is labeled with male wing extensions which is part of their courtship behavior. With this dataset we were particularly interested in whether our model could simulate a virtual fly in a complex, dynamic environment.
+
+SynthFly is a synthetic dataset containing a single fly moving inside of a rectangular chamber with a stationary object located in the center. The fly is synthesized to move according to the control laws listed in Figure 2. The purpose of this dataset is to test whether our model could learn generative control rules, particularly ones that enforce non-deterministic behavior (see laws 4 and 5).
+
+IAM-OnDB (Liwicki & Bunke, 2005) contains handwritten text from 195 different writers, acquired using a smart whiteboard that records a list of (x, y) coordinates for each pen stroke. The data is weakly labeled, with each sequence separated into short lines of transcribed text. For consistency with our framework we hand annotated strokes of 10 writers, marking the start and end of the 26 lower case characters, which we use along with data from 35 unlabeled writers for our experiments.
+
+All data, along with details about training and test splits, will be available in supplementary material.
+
+# IAM-OnDB
+
+![](images/edb44f99f9043a58e041cc7e4c89c107a34c780fcf108bf58eacc0d3dee00cbb.jpg)
+
+![](images/93b3dff0bfaf4facff66b1d2039e823118aebff7174260f4fcc03bdad39911b1.jpg)
+
+# SynthFly - control laws:
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>total #frames</td><td rowspan=1 colspan=1>#trials</td><td rowspan=1 colspan=1>#agentsper trial</td><td rowspan=1 colspan=1>#labeledactions</td><td rowspan=1 colspan=1>total #instances</td><td rowspan=1 colspan=1>% frames</td></tr><tr><td rowspan=1 colspan=1>Fly-vs-Fly</td><td rowspan=1 colspan=1>3.7M</td><td rowspan=1 colspan=1>47</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>8599</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>FlyBowl</td><td rowspan=1 colspan=1>0.6M</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>961</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>SynthFly</td><td rowspan=1 colspan=1>0.4M</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>IAM-OnDB*</td><td rowspan=1 colspan=1>1.5M</td><td rowspan=1 colspan=1>45</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>26</td><td rowspan=1 colspan=1>12049</td><td rowspan=1 colspan=1>88</td></tr></table>
+
+1) walk forward with random noise   
+2) at wall, rotate in direction of least resistance   
+3) when object in front visual field, walk towards it   
+4) extend either left or right wing (random)   
+5) at object, rotate left or right (alternating)   
+6) repeat 1)
+
+Figure 2: Snapshots from the three labeled datsets used for our evaluation and a list of control laws used to generate synthetic fly trajectories. The table summarizes the statistics of each experimental dataset, where total # frames sums over all trials (videos / text documents) within an experiment and agents within a trial, total # instances sums over all action classes, and $\%$ frames is the percent of frames in labeled sequences containing actions of interest. IAM-OnDB\* is a subset of IAM-OnDB with additional annotations for 10 of its trials.
+
+![](images/0d551afa184533b64e9762b219e8b1bf98c01276ba0f89494409c508623708fa.jpg)  
+Figure 3: Left: Sensory input $v$ for fruit flies represents how a fly sees other flies and chamber walls, their motor control $_ x$ lets them move their body along 8 dimensions (incl. right wing ang/len). Right: Motor control $x$ for handwriting is represented as vector (dx, dy) along with binary stroke visibility $\mathbf { Z }$ (pen on/off whiteboard).
+
+Fly representation: Motor control features, $x$ , describe the locomotion of a fly. The flies are tracked from video using FlyTracker2 and from the tracked fly poses we extract motion features represented in the fly’s frame of reference. The 8 motion features, displayed on top of the close-up fly3 in Figure 3, are designed such that they can animate virtual fly agents. Sensory input features, $v$ , are inspired by a fly’s compound eye which consist of 750 compactly aligned ommatidia. Approximating its vision as a one dimensional $3 6 0 ^ { \circ }$ view, we place $7 2 5 ^ { \circ }$ circular sectors around a fly agent, aligned with its orientation, and project flies that overlap with a sector onto its artificial retina with intensity inversely proportional to their distance to the agent. Thus, flies close to the agent yield high intensity in several pixels and flies that are far away take up few pixels with low intensity (compare scene in Figure 3 with $v$ sensed by the agent). We represent chamber walls similarly, projecting them onto a separate channel decreasing intensity exponentially with distance to the agent. This representation is invariant of the shape of the chamber and the number of flies present in the chamber.
+
+In order to compare our model with methods presented in Eyjolfsdottir et al. (2014), independently of feature representation, we use the 36 features provided with the Fly-vs-Fly dataset. We assign the first 8 dimensions (describing fly’s motion) as motor control $x$ , and the remaining features (describing fly’s position relative to the other fly, and feature derivatives) as sensory input $v$ .
+
+Handwriting representation: We represent the motor control, $x$ , as (dx, dy, z) where dx and dy are the x and y displacements from the previous pen recording and $\mathbf { Z }$ is a binary variable denoting segment visibility. We normalize dx and dy for each writer, providing invariance to writing speed, but character size (number of points per character), slant, and other variations are not explicitly accounted for. As handwriting is not influenced by a changing environment, but rather a function of the internal state and current motion of the writer, we leave the sensory input, $v$ , empty.
+
+# 5 EXPERIMENTS AND ANALYSIS
+
+We evaluate our framework on three objectives: classification, simulation, and discovery. For classification we show the benefit of motion prediction as an auxiliary task, compare our performance on Fly-vs-Fly with previous work, and analyze the performance on IAM-OnDB. We qualitatively show that simulation results for fly behavior and handwriting look convincing, and that the model is able to learn control laws used to generate the SynthFly dataset. For discovery we show that hidden states of the model, trained only to predict motion (without any action labels), cleanly capture high level phenomena that affect behavior, such as fly gender and writer identity.
+
+Model details: We trained a separate model for each dataset, using a sequence length of 50, a batch size of 20, and 51 bins per dimension for motion prediction. For fly behavior data we used 2 levels of GRU cells (4 cells total) of 100 units each, and for handwriting we used 3 levels of GRU cells (6 cells total) of 200 units each. Parameters were determined using a rough parameter sweep on a subset of the training data. Further training details are described in supplementary material. Our model is implemented in Tensorflow (Abadi et al., 2015).
+
+a) benefit of auxiliary task
+
+b) Fly-vs-Fly comparison with prior work   
+
+<table><tr><td></td><td>F1 frame F1 bout</td><td></td><td>F*</td></tr><tr><td>hand crafting + windowSVM+ HMM</td><td>0.760</td><td>0.770</td><td>0.765</td></tr><tr><td>BENet</td><td>0.717</td><td>0.665</td><td>0.690</td></tr><tr><td>BENet + filter</td><td>0.716</td><td>0.739</td><td>0.727</td></tr><tr><td>BESNet</td><td>0.734</td><td>0.627</td><td>0.677</td></tr><tr><td>BESNet + filter</td><td>0.752</td><td>0.724</td><td>0.738</td></tr></table>
+
+![](images/08cc50ddfa9eb2302d406d2b269df3c0d7573a8bc0186c48acfdcb44a1c61412.jpg)  
+Figure 4: a) Performance of model trained with (solid, BESNet) and without (dashed, BENet) motion prediction, showing that BESNet requires significantly fewer labels to match the performance of BENet. b) Our model reaches performance competitive with Eyjolfsdottir et al. (2014), without handcrafting or context from future frames. c) Input $x$ , label $y$ , and classification score $\hat { y }$ , colored according to character label, showing high confusion at the beginning of characters, partly explaining the lower F1-frame performance on IAM-OnDB.
+
+# c) IAM-OnDB example
+
+![](images/947cbe53d030058ac0feed431ce63a3ff067627bb0db24994807f5151a7428f7.jpg)
+
+# 5.1 CLASSIFICATION
+
+Action labeling involves recording the start frame, end frame, and class label, of each action interval, which we refer to as a bout. From a sequence of frame-wise classifications, consecutive frames of the same class prediction are consolidated into a single bout. To measure both duration and counting accuracy we use the performance measures described in Eyjolfsdottir et al. (2014), namely the F1 score (harmonic mean of precision and recall), on a per-frame and per-bout level. Bout-wise precision and recall is computed by assigning predicted bouts to ground truth bouts one-to-one, maximizing intersection over overlap. $\mathrm { F ^ { * } }$ is the harmonic mean of the F1-frame and F1-bout scores.
+
+Our goal for classification is to reduce the number of training labels without loss in performance. To measure the benefit of motion prediction as an auxiliary task we compare our model, which we will refer to as Behavior Embedding Sensory-motor Network (BESNet), with our model without its generative part (similar to a standard RNN but with action labels embedded in hidden states, shown in Figure 5), referred to as Behavior Embedding Network (BENet). We trained both models on each dataset using $3 \mathrm { - } 1 0 0 \%$ of available labels. As BESNet is trained to predict future motion it makes use of unlabeled sequences during training whereas BENet does not. Figure 4 a) shows the frame-wise F1 score for each of the 36 trained models (3 datasets, 6 label fractions, 2 model types), averaged over all action classes in a dataset. This experiment shows that motion prediction as an auxiliary task significantly improves classification performance, especially when labels are scarce.
+
+In Figure $^ { 4 \mathrm { ~ b ~ } }$ ) we compare the performance of our network with the best performing method on Flyvs-Fly, a window based support vector machine (SVM) that uses hand crafted window features and fits an HMM to the output for smoother classification – outperforming sophisticated methods such as structured SVM. For this comparison we used the features published with the dataset as described in Section 4. Although recurrent networks implicitly enable smooth classification, different actions require different levels of smoothness. To avoid over segmentation of action intervals, we smooth the output of our network by applying a flat filter, of size equal to $10 \%$ of the mean duration of each class. Our results show that filtering significantly improves the bout-wise performance and that our performance on the Fly-vs-Fly test set is comparable with that of Eyjolfsdottir et al. (2014), using no handcrafting and no context of future frames (apart from smoothing).
+
+We applied the same type of filtering to the classification output of IAM-OnDB as we did for Flyvs-Fly and obtained an F1-(frame, bout) of (0.445, 0.585) averaged over all classes, and (0.567, 0.690) averaged over all instances (weighted average of classes). Figure $4 \mathrm { ~ c ~ }$ ) demonstrates that at the beginning of some characters there tends to be more confusion in $\hat { y }$ than towards the end, which is unsurprising as the beginning of these characters looks approximately the same.
+
+# 5.2 MOTION PREDICTION
+
+Before we look at simulation results, we quantitatively measure the accuracy of one-step predictions. We compute the log-likelihood of FlyBowl test sequences under the motion prediction model: $\begin{array} { r } { \mathrm { l o g l i k } ( x ) = { \bar { \sum _ { i = 1 } ^ { T - 1 } } } \sum _ { d = 1 } ^ { 8 } \log \left( { \tilde { x } _ { i + 1 } ^ { d } } \cdot { \hat { x } _ { i + 1 } ^ { d } } \right) } \end{array}$ , where $\tilde { x } _ { i + 1 } ^ { d }$ is the ground truth indicator vector for bins of motion dimension $d$ , and $\hat { x } _ { i + 1 } ^ { d }$ is a probability distribution over the bins predicted by the model.
+
+We compare our model with the following motion prediction policies: 1) uniform distribution over bins, 2) distribution over bins computed from training set, 3) constant motion policy that copies previous indicator vector as motion prediction, and 4) a smooth version of 3) filtered using an optimized Gaussian kernel. The results, shown in Figure 5, demonstrate that the recurrent models learn a significantly better policy. In addition, we compare variants of our model and a standard RNN within our framework (with the same sensory-motor representation, multimodal output, and GRU cells) which shows that recurrence is essential for good motion prediction and that diagonal connections provide a slight performance gain. In Section 5.4 we show the main benefit of the diagonals.
+
+a) network variants
+
+![](images/6122d23e292ada2f9718073ff6e41343732ee6fba496e43b45bb24dce1c0157e.jpg)  
+Figure 5: a) Network variants used in experiments (compare BESNet to highlighted cells in its unrolled visualization in Figure 1). b) 1-step motion prediction performance on FlyBowl testset, see text above for explanation.
+
+# 5.3 SIMULATION
+
+xi  i One-step prediction performance does not clearly reveal whether a model has learnt the generative L( , ) = sum_f(crossentropy ( , ) xf i+1 \~ xf i+1 ^ xi+1 xi+1^process underlying the training data. In order to get a better notion of that we look at simulations produced by the learnt models, which can be thought of as very long term predictions. As motion 1xi \~ fground truthprediction is probabilistic, comparing long term predictions with ground truth becomes difficult as ^the domain of probable positions becomes exponentially large. Qualitative inspection, however, x      i gives a good intuition about whether the simulated agent has learnt reasonable control laws.
+
+While the underlying generative process for the motion of real flies is unknown, simulations from the model trained to imitate them suggest that the model has learnt a reasonable policy. During simulation we place no physical constraints on how the flies can move but our results show that simulated FlyBowl agents avoid collisions with the chamber walls and with other flies, and that agents are attracted to other flies and occasionally engage in courtship-like behavior. This is shown in Figure 6 and better visualized as video in supplementary material.
+
+Simulated handwriting is easier to visualize in an image and we are used to recognizing the structure it should produce. Figure 7 shows that the model trained on IAM-OnDB produces character-like trajectories in word-like combinations. Note that handwriting is generated one (dx, dy, z) vector at a time, and each character is composed of roughly 20 such points on average. On the right hand side of Figure 7 we show that we can increase the generation of specific characters by activating their classification units (forcing their values to 1 and others to 0) during simulation.
+
+Figure 8 shows the output of two recurrent units of the SynthFly model that indicate that the model was able to learn control rules that were designed to ensure a multimodal motion prediction target. One unit fires in correlation with either left or right wing extension, and the other toggles between a negative and positive state as the agent turns left or right to avoid the object. In supplementary material we show a video of this simulation and compare it to a simulation from the model trained with deterministic motion prediction. This comparison clearly demonstrates the benefit of treating motion prediction as a distribution over bins, as the deterministic agent quickly becomes degenerate.
+
+![](images/bdc4ebe3a762a85ec23da17e615604be7192cc6a4286f710de08165a46cfed82.jpg)  
+Figure 6: a) $1 0 \mathrm { ~ x ~ } 2 0$ -frame lookaheads (simulations) for each test fly from its current location, demonstrating the non-deterministic nature of the motion prediction. The ground truth 20-frame future trajectory is outlined in black for comparison. b) shows trajectories of 20 flies simulated for 1000 frames, and c) shows 1000-frame trajectories for 20 real flies interacting. The simulation shows that the model has learnt a preference for staying near the boundary and to avoid walking through the boundary.
+
+![](images/416b74bfcbf5d01bcf21d4dd8a217f057019397ebe4af0b863ca126cad460643.jpg)  
+Figure 7: Left: Text generated by our model, one vector at a time (approximately 20 vectors per character). Right: Text generated by the same model while ”activating” character classification units of the model during simulation, shown in two lines per character.
+
+![](images/0501a2c84e7c8147b2909c69de0e18e50cd4367858626bafb09585cc17d850a2.jpg)  
+r l r l l l l l r lr l r l l l l l r lFigure 8: Comparison between synthetic fly (ground truth) and simulation by our model. The wing angles, distance to object, and left/right turn show the agent’s motion over time, and the two hidden units indicate that the model has learnt to represent control laws 4 and 5 used to generate the synthetic trajectories.
+
+# 5.4 DISCOVERY
+
+We motivated the structure of our network, specifically the diagonal connections between discriminative and generative cells, with the intuition that it would allow higher levels of the network to better represent high level phenomena. To verify this we train models to only predict future motion, with no classification target, and visualize what the hidden states capture. We apply the model to $[ x , v ]$ , obtaining hidden state vectors $h ^ { l }$ and $\hat { h } ^ { l }$ , $l \in \{ 1 , . . . , L \}$ , and prediction $\hat { x }$ , map the data points (time steps of each fly/writer) from each state to 2 dimensions using t-distributed stochastic neighbor embedding (tSNE, Maaten & Hinton (2008)), and plot them in colors based on known phenomena.
+
+![](images/c2db86514d23a0e71c2f7e8bdb56bbc226676c462e4a36af2b63e733b6e74657.jpg)  
+Figure 9: Left: Hidden state values of a 3 level model trained without any labels on IAM-OnDB, reduced to 2 dimensions using tSNE mapping. The network discovers writer identity at the highest level, while lower level phenomena such as stroke length are represented at lower levels. Right: tSNE mapped input, output, and hidden state values of FlyBowl model (trained without any labels), colored by gender and male wing extension.
+
+In Figure 9 we plot the data points of a 3 level $( \mathrm { L } { = } 3 )$ ) model trained on IAM-OnDB in this low dimensional embedding, and color code them according to three criteria: stroke length, character class, and writer identity. The results show that stroke length is well clustered at low levels but not at high levels, characters are best clustered at mid to top discriminative levels, and writer identity is extremely well clustered at the top generative level but not at low levels. We ran the same experiment for the model trained without diagonal connections (which without a classification target is effectively a standard RNN with 6 levels of GRU cells), which did not learn to represent writer identity in any of its hidden states. Intuitively this is because the network has to carry low level information through every state to predict low level information at the other end, whereas BESNet carries it directly through the low level diagonal connections leaving higher hidden states free to capture high level information. A visualization comparing both models is shown in supplementary material along with a quantitative measurement of our observation.
+
+The same visualization for the model trained on FlyBowl, where data points are color coded by gender and left/right wing extension, shows (Figure 9, right) that gender is very mixed in the input and output states but well separated in the top generative state, while lower level information such as wing extension is well represented at lower levels of the network.
+
+# 6 CONCLUSION
+
+We have proposed a framework for modeling the behavior of animals, that simultaneously classifies their actions and predicts their motion. We showed empirically that motion prediction (a target that requires no labeling) is a good auxiliary task for training action classifiers, especially when labels are scarce. We also showed that the generative task can be used to simulate trajectories that look natural to the human eye, and that activating classification units increases the frequency of that action in the simulation. Finally, we showed that our model lends itself well to discovery of high level information from the data, by visualizing what is captured in its hidden states.
+
+We tested the framework on two types of data, fly behavior and online handwriting, and we anticipate that it will scale to more complex data with appropriate tuning of hyperparameters and abstraction of visual input. For example, application to human motion capture with 1st person video as sensory input might require greater model complexity to account for the higher dimensional motor control and pre-processing of the sensory input, e.g. with a convolutional neural network, to extract a higher level sensory representation before feeding it to the dynamical system.
+
+Moving forward, we are interested in working on hierarchical label embedding in the states, assigning higher order activities to units higher in the network. Along those lines, a discrete recurrent network could be trained separately on the wealth of available text, and be placed on top of a realvalued handwriting network. We also aim to explore how this framework can be used to understand the neural mechanisms underlying the generation of behavior in flies.
+
+# 7 ACKNOWLEDGMENTS
+
+We would like to thank David J. Anderson and Charless Fowlkes for insightful discussions, and acknowledge Google and The Simons Foundation for their financial support.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´ Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´ berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org.
+
+David J Anderson and Pietro Perona. Toward a science of computational ethology. Neuron, 84(1): 18–31, 2014.
+
+Pierre Baldi. Autoencoders, unsupervised learning, and deep architectures. ICML unsupervised and transfer learning, 27(37-50):1, 2012.
+
+Gordon J Berman, Daniel M Choi, William Bialek, and Joshua W Shaevitz. Mapping the stereotyped behaviour of freely moving fruit flies. Journal of The Royal Society Interface, 11(99):20140672, 2014.
+
+Valentino Braitenberg. Vehicles Experiments in Synthetic Psychology. MIT Press, 1984.
+
+Xavier P Burgos-Artizzu, Piotr Dollar, Dayu Lin, David J Anderson, and Pietro Perona. Social ´ behavior recognition in continuous video. In Computer Vision and Pattern Recognition (CVPR), 2012 IEEE Conference on, pp. 1322–1329. IEEE, 2012.
+
+Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014.
+
+Junyoung Chung, Kyle Kastner, Laurent Dinh, Kratarth Goel, Aaron C Courville, and Yoshua Bengio. A recurrent latent variable model for sequential data. In Advances in neural information processing systems, pp. 2962–2970, 2015.
+
+Anthony I Dell, John A Bender, Kristin Branson, Iain D Couzin, Gonzalo G de Polavieja, Lucas PJJ Noldus, Alfonso Perez-Escudero, Pietro Perona, Andrew D Straw, Martin Wikelski, et al. Auto- ´ mated image-based tracking and its application in ecology. Trends in ecology & evolution, 29(7): 417–428, 2014.
+
+Eyrun Eyjolfsdottir, Steve Branson, Xavier P Burgos-Artizzu, Eric D Hoopfer, Jonathan Schor, David J Anderson, and Pietro Perona. Detecting social actions of fruit flies. In Computer Vision– ECCV 2014, pp. 772–787. Springer, 2014.
+
+Alan Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on, pp. 6645–6649. IEEE, 2013.
+
+Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Hueihan Jhuang, Estibaliz Garrote, Xinlin Yu, Vinita Khilnani, Tomaso Poggio, Andrew D Steele, and Thomas Serre. Automated home-cage behavioural phenotyping of mice. Nature communications, 1:68, 2010.
+
+Mayank Kabra, Alice A Robie, Marta Rivera-Alba, Steven Branson, and Kristin Branson. Jaaba: interactive machine learning for automatic annotation of animal behavior. nature methods, 10(1): 64–67, 2013.
+
+Marcus Liwicki and Horst Bunke. Iam-ondb-an on-line english sentence database acquired from handwritten text on a whiteboard. In Document Analysis and Recognition, 2005. Proceedings. Eighth International Conference on, pp. 956–961. IEEE, 2005.
+
+Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(Nov):2579–2605, 2008.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+J Moore. Some thoughts on the relation between behavior analysis and behavioral neuroscience. The Psychological Record, 52(3):261, 2002.
+
+Kevin Patrick Murphy. Dynamic bayesian networks: representation, inference and learning. PhD thesis, University of California, Berkeley, 2002.
+
+Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semisupervised learning with ladder networks. In Advances in Neural Information Processing Systems, pp. 3532–3540, 2015.
+
+William M Roberts, Steven B Augustine, Kristy J Lawton, Theodore H Lindsay, Tod R Thiele, Eduardo J Izquierdo, Serge Faumont, Rebecca A Lindsay, Matthew Cale Britton, Navin Pokala, et al. A stochastic neuronal model predicts random search behaviors at multiple spatial scales in c. elegans. eLife, 5:e12572, 2016.
+
+DE Rumenlhart, Geoffrey E Hinton, and Ronald J Williams. Learning internal representation by error propagation, parallel distributed processing. Explor. Microstruct. Cognition, 1:318–362, 1986.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+Herbert A Simon. The sciences of the artificial. MIT press, 1996.
+
+Kathleen K Siwicki and Edward A Kravitz. Fruitless, doublesex and the genetics of social behavior in drosophila melanogaster. Current opinion in neurobiology, 19(2):200–206, 2009.
+
+Niko Tinbergen. On aims and methods of ethology. Zeitschrift fur Tierpsychologie ¨ , 20(4):410–433, 1963.
+
+Harri Valpola. From neural pca to deep unsupervised learning. Adv. in Independent Component Analysis and Learning Machines, pp. 143–171, 2015.
+
+Alexander B Wiltschko, Matthew J Johnson, Giuliano Iurilli, Ralph E Peterson, Jesse M Katon, Stan L Pashkovski, Victoria E Abraira, Ryan P Adams, and Sandeep Robert Datta. Mapping sub-second structure in mouse behavior. Neuron, 88(6):1121–1135, 2015.

parse/train/BkLhzHtlg/BkLhzHtlg_content_list.json

@@ -0,0 +1,1358 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING RECURRENT REPRESENTATIONS FORHIERARCHICAL BEHAVIOR MODELING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            753,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Eyrun Eyjolfsdottir1, Kristin Branson2, Yisong $\\mathbf { Y u e ^ { 1 } }$ , & Pietro Perona1 1California Institute of Technology, 2Janelia Research Campus HHMI ",
+        "bbox": [
+            183,
+            167,
+            679,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            224,
+            544,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose a framework for detecting action patterns from motion sequences and modeling the sensory-motor relationship of animals, using a generative recurrent neural network. The network has a discriminative part (classifying actions) and a generative part (predicting motion), whose recurrent cells are laterally connected, allowing higher levels of the network to represent high level behavioral phenomena. We test our framework on two types of tracking data, fruit fly behavior and online handwriting. Our results show that 1) taking advantage of unlabeled sequences, by predicting future motion, significantly improves action detection performance when training labels are scarce, 2) the network learns to represent high level phenomena such as writer identity and fly gender, without supervision, and 3) simulated motion trajectories, generated by treating motion prediction as input to the network, look realistic and may be used to qualitatively evaluate whether the model has learnt generative control rules. ",
+        "bbox": [
+            233,
+            255,
+            764,
+            434
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            454,
+            336,
+            469
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Behavioral scientists strive to decode the functional relationship between sensory input and motor output of the brain (Tinbergen, 1963; Moore, 2002). In particular, ethologists study the natural behavior of animals while neuroscientists and psychologists study behavior in a controlled environment, manipulating neural activations and environmental stimuli. These studies require quantitative measurements of behavior to discover correlations or causal relationships between behaviors over time or between behavior and stimuli; automating this process allows for more objective and precise measurements, and significantly increased throughput (Dell et al., 2014; Anderson & Perona, 2014). Many industries are also concerned with automatic measurement and prediction of human behavior, for applications such as surveillance, assisted living, sports analytics, and self driving vehicles. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            611
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Behavior is complex and may be perceived at different time-scales of resolution: position, trajectory, action, activity. While position and trajectory are geometrical notions, action and activity are semantic in nature. The analysis of behavior may therefore be divided into two steps: (a) detection and tracking, where the pose of the body over time is estimated, and (b) action/activity detection and classification, where motion is segmented into meaningful intervals, each one of which is associated with a goal or a purpose. Our work focuses on going from (a) to (b), that is to detect and classify actions from motion trajectories. We use data for which tracking and pose estimation is relatively simple, which lets us focus on modeling the temporal dynamics of pose trajectories without worrying about errors stemming from low level feature extraction. ",
+        "bbox": [
+            174,
+            617,
+            823,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Supervised learning is a powerful tool for learning action classifiers from expert-labeled examples (Jhuang et al., 2010; Burgos-Artizzu et al., 2012; Kabra et al., 2013; Eyjolfsdottir et al., 2014). However, it has two drawbacks. First, it requires a lot of training labels which involves time consuming and painstaking annotation. Second, behavior measurement is limited to actions that a human can perceive and believes to be important. We propose a framework that takes advantage of both labeled and unlabeled sequences; it simultaneously learns to predict future motion and detect actions, allowing the system to learn from fewer expert labels and discover unbiased behavior representations. ",
+        "bbox": [
+            174,
+            750,
+            823,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The framework models the sensory-motor relationship of an agent, predicting motion based on its sensory input and motion history. It can be used to simulate an agent by iteratively feeding motion predictions as input to the network and updating sensory inputs accordingly. A model that can simulate realistic behavior has learnt to emulate the generative control laws underlying behavior, which could be a useful tool for behavior analysis (Simon, 1996; Braitenberg, 1984). ",
+        "bbox": [
+            176,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our model is constructed with the goal that it will learn to represent and discover behaviors at different semantic scales, offering an unbiased way of measuring behavior with minimal human input. Recent work by Berman et al. (2014) and Wiltschko et al. (2015) shows promising results towards unsupervised behavior representation. Compared to their work our framework offers three advantages. Our model learns a hierarchical embedding of behavior, can be trained semi-supervised to learn specific behaviors of interest, and our sensory-motor representation enables the model to learn interactive behavior of an agent with other agents and with its environment. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our experiments focus mainly on the behavior of fruit flies, Drosophila Melanogaster, a popular model organism for the study of behavior (Siwicki & Kravitz, 2009). To explore the generality of our approach we also test our model on online handwriting data, an interesting human behavior that produces two dimensional trajectories. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To summarize our contributions: ",
+        "bbox": [
+            176,
+            271,
+            388,
+            285
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1) We propose a framework that simultaneously models the sensory-motor relationship of an agent and classifies its actions, and can be trained with partially labeled sequences.   \n2) We show that motion prediction is a good auxiliary task for action classification, especially when training labels are scarce.   \n3) We show that simulated motion trajectories resemble trajectories from the data domain and can be manipulated by activating discriminative cell units.   \n4) We show that the network learns to represent high level information, such as gender or identity, at higher levels of the network and low level information, such as velocity, at lower levels.   \n5) We test our framework on the spontaneous and sporadic behavior of fruit flies, and the intentional and structured behavior of handwriting. ",
+        "bbox": [
+            174,
+            291,
+            826,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            326,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Hidden Markov models (HMMs) have been extensively used for sequence classification. The motivating assumption for HMMs is that there exists a process that transitions with some probability between discrete states, each of which emits observations according to some distribution, and the objective is to learn these functions given a sequence of observations and states. This model is limited in that its transition functions are linear, state space is discrete, and emission distribution is generally assumed to be Gaussian, although generalizations of the model that fall under the category of dynamic Bayesian networks are more expressive (Murphy, 2002). ",
+        "bbox": [
+            173,
+            492,
+            825,
+            589
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recurrent neural networks (RNNs) have recently been shown to be extremely successful in classifying time series data, especially with the popularization of long short term memory cells (Hochreiter & Schmidhuber, 1997), in applications such as speech recognition (Graves et al., 2013). RNNs have also been used for generative sequence prediction of handwriting (Graves, 2013) as well as speech synthesis (Chung et al., 2015). ",
+        "bbox": [
+            174,
+            595,
+            823,
+            666
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Imitation learning involves learning to map a state to an action, from demonstrated sequences of actions. This is a supervised learning technique which, when implemented as an RNN, can be trained via backpropagation using action-error computed at every time step. The problem with this approach is that the domain of states that an agent is trained on consists only of states that the demonstrators encounter, and when an agent makes a mistake it finds itself in a situation never experienced during training. Reinforcement learning handles this by letting an agent explore the domain using an action policy, and updating the policy based on a goal-specific penalty or reward which may be obtained after taking several actions. This exploration can be extremely expensive, and therefore it is common to precede reinforcement learning with imitation learning to start the agent off with a reasonable policy. This strategy is used in (Mnih et al., 2015) where an agent is trained to play Atari games, and in (Silver et al., 2016) for mastering the game of GO. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            825
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Autoencoders (Rumenlhart et al., 1986) have been used in semi-supervised classification to pretrain a network on an auxiliary task, such as denoising, to prevent overfitting on a small number of labeled data (Baldi, 2012). Recent work in this area (Rasmus et al., 2015) proposes to train on the primary and auxiliary task concurrently and using lateral connections (Valpola, 2015) between encoding and decoding layers to allow higher layers of the network to focus on high level features. ",
+        "bbox": [
+            174,
+            833,
+            823,
+            902
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our framework takes inspiration from each of the works described here. ",
+        "bbox": [
+            173,
+            909,
+            643,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            267,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our model is a recurrent neural network, with long short term memory, that simultaneously classifies actions and predicts future motion of agents (insects, animals, and humans). Rather than actions being a function of the recurrent state, as is common practice, our model embeds actions in recurrent state units. This way the recurrent function encodes action transition probabilities and motion prediction is a direct function of actions, similar to an HMM. The network takes as input an agent’s motion and sensory input at every time step, and outputs the agent’s next move according to a policy, which is effectively learnt via imitation learning. Similar to autoencoders, our model has a discriminative path, used to embed high level information, and a generative path used to reconstruct the input domain, in our case filling in the future motion. Each discriminative recurrent cell is fully connected with its corresponding generative cell, allowing higher level states to represent higher level information, similar to the idea of Ladder networks (Valpola, 2015). ",
+        "bbox": [
+            173,
+            133,
+            825,
+            286
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1518169447b0a1f01f97c62b8a104d7d33c490630ecb6c985320dcffc79d8265.jpg",
+        "image_caption": [
+            "Figure 1: Left: A 3D depiction of our network unrolled for 3 timesteps. The highlighted cells show the path from an input through a classification cell to a motion prediction output. During training, motion prediction loss $\\mathcal { L } _ { x }$ is computed at every timestep, and classification loss $\\mathcal { L } _ { y }$ is computed only at frames for which labels are provided. The diagonal connections between discriminative and generative cells enable higher levels of the network to represent high level information. Vector $v$ represents agent’s sensory input, $_ x$ its motion, $h$ its internal state, and $_ y$ labeled actions. Right: A zoom in on the blue and green cells showing the recurrent state (horizontal arrows) and inputs to the recurrent cell function $f$ . Merging of arrows represents vector concatenation, and branching vector duplication. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            304,
+            818,
+            518
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            669,
+            326,
+            681
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The model can be thought of as two parallel recurrent networks: The discriminative network takes as input an agent’s motion, $x$ , and environmental sensory input, $v$ , and propagates them up through its hidden states which encode high level information, including action labels, $y$ . The generative network decodes the states of the discriminative network, propagating information down to predict the agent’s motion at the next time step, $\\hat { x }$ . The two networks have the same number of layers and are connected diagonally at each layer such that the information encoded in the hidden units of the discriminative network is propagated to the corresponding layer of the generative network at the next time step. Intuitively, these can be thought of as skip connections or “shortcuts” which let low level motion information propagate directly through lower levels of the network, leaving higher levels of the network free to represent high level phenomena, such as goals or individual characteristics. Our experiments confirm this intuition. The model can be trained without any action labels, in which case the hidden state may be used to discover high level information about the data, or with action labels for a subset of the data, in which case each action is assigned to a hidden state unit and will thus contribute to subsequent motion prediction and action classification. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The flow of information through the network and the cost associated with its classification and prediction is expressed by the following equations: ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/8cfbcb94cbe6d80e4e1b1b337a3f51c147e58118fc5f8df92fd4a0f7be6e402a.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Discriminative</td><td>Generative</td></tr><tr><td>h=f（[xi,Ui],h²-1)</td><td>h+1=f(h,h）</td></tr><tr><td>h²=f(h-1,h²-1)</td><td>i= h+1=f([hi+1,h&#x27;],h） +1 T Cx=</td></tr><tr><td>i = (h²(1: N) +1)/2</td><td>xi+1=g(hi+1) C = λCy +(1-λ)Cx</td></tr></table>",
+        "bbox": [
+            204,
+            113,
+            794,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $f$ is a recurrent cell function, $g$ is a transformation, $\\mathcal { L } _ { y }$ computes classification loss (on frames for which labels are provided) and $\\mathcal { L } _ { x }$ computes motion prediction loss. The total cost, $C$ , combines the misclassification cost, $C _ { y }$ , and misprediction cost, $C _ { x }$ , using $\\lambda$ to trade off the two. $N$ is the number of labeled action classes, $L$ the number of levels, $T$ the number of frames, $l$ is the layer index and $i$ the frame index. The first $N$ units of state $h ^ { L }$ are forced to be classification units, they are scaled from [-1 1] to [0 1] (assuming $f$ ’s activation function is tanh) and assigned to $\\hat { y }$ . ",
+        "bbox": [
+            174,
+            228,
+            825,
+            313
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The model is presented as part of a general framework where $f , g$ , and number of levels/units are architectural choices to be optimized for each dataset. For our experiments we found that 2-3 levels of recurrent cells with 100-200 units worked well, with $f$ as a gated recurrent unit (GRU) cell (Cho et al., 2014) and $g$ as linear transformation. The choice of loss functions depends on the target type; sigmoid cross entropy for multitask classification (where actions can co-occur), softmax cross entropy for multiclass classification (where actions are mutually exclusive), and sum of squared differences for regression (where outputs are real valued). The optimal value for $\\lambda$ depends both on the output domain of $\\mathcal { L } _ { y }$ and $\\mathcal { L } _ { x }$ and whether the primary goal is classification or simulation. Data-specific model- and training parameters are described in Section 5 and further training details are discussed in supplementary material1. ",
+        "bbox": [
+            173,
+            319,
+            825,
+            458
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 MULTIMODAL PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            476,
+            401,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Evidence suggests that animal behavior is nondeterministic (Roberts et al., 2016); thus, motion prediction may be better represented as a probability distribution than a function. When future motion is multimodal, the best regression model will pick the average motion of the different modes which may not lie within any of the actual modes (visualized in supplementary material). This observation has been made by others in the context of modeling real-valued sequences with RNNs, (Graves, 2013) model the output of an RNN as a Gaussian mixture model and (Chung et al., 2015) additionally model the hidden recurrent states as random variables. We take a nonparametric approach, making no assumption about the shape of the distribution. We discretize motion into bins and treat the task of predicting future motion as independent multiclass classification problems for each motion feature, which results in a probability distribution over all bins for each dimension. More concretely, each dimension of $x$ is assigned $n$ bins and the target for $\\hat { x } _ { i + 1 }$ becomes the binned version of $x _ { i + 1 }$ , denoted as $\\tilde { x } _ { i + 1 }$ , which has exactly one nonzero entry for each dimension of $x$ . The prediction $\\hat { x } _ { i + 1 }$ then becomes a discrete distribution over the bins for each feature dimension and the motion prediction loss becomes $\\begin{array} { r } { \\mathcal { L } _ { x } ( x _ { i + 1 } , \\hat { x } _ { i + 1 } ) = \\sum _ { d } ( \\mathrm { c r o s s e n t r o p y } ( \\tilde { x } _ { i + 1 } , \\hat { x } _ { i + 1 } ) ) } \\end{array}$ , as opposed to the Euclidean distance in the case when $x$ is a real valued vector. The number of bins determines the granularity of the motor control; a greater number of bins means more precise motion control but is also more expensive to train. ",
+        "bbox": [
+            173,
+            501,
+            825,
+            737
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 SIMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            755,
+            303,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given a model that can predict an agent’s future motion from its current state, a virtual agent can be simulated by iteratively feeding predicted motion $\\hat { x } _ { i + 1 }$ as input $x _ { i + 1 }$ to the network. We pick a bin by sampling from the distribution given by $\\hat { x } _ { i + 1 }$ and assign a real value to $x _ { i + 1 }$ by sampling uniformly from the selected bin. An agent’s perception of the environment depends on the agent’s location, and therefore sensory features $v _ { i + 1 }$ must be updated for each forward simulation step to correspond to the agent’s perspective at time $i + 1$ . When simulating multiple agents that interact with one another, each agent is moved according to its $x _ { i + 1 }$ and then $v _ { i + 1 }$ is computed for each agent based on the new configuration of all agents. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            892
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            251,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our framework is agent centric, it models the behavior of each agent individually based on how it moves and senses its surroundings, including other agents. It is applicable to any data that can be represented in terms of motor control (e.g. joystick controller) and sensory input that captures context from the environment (e.g. 1st person camera). We test our model on two types of data, fly behavior and online handwriting. Both can be thought of as a type of behavior represented in the form of trajectories, but the two are complementary. First, flies behave spontaneously, performing actions of interest sporadically and in response to their environment, while handwritten text is intensional and highly structured. Second, handwriting varies significantly between different writers in terms of size, speed, slant, and proportions, while inter-fly variation is relatively small. We use 4 datasets for our experiments (listed below) with the aim to answer the following questions: 1) does motion prediction improve action classification, 2) can the model generate realistic simulations (does it learn the sensory-motor control), and 3) can the model discover novel behavioral phenomena? ",
+        "bbox": [
+            174,
+            138,
+            825,
+            305
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fly-vs-fly (Eyjolfsdottir et al., 2014) contains pairs of fruit flies engaging in 10 labeled courtshipand aggressive behaviors. We include this dataset in our experiments to see how our model compares with our previous action detection work which relies on handcrafted window features. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            354
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "FlyBowl is a video of 10 male and 10 female fruit flies interacting and is labeled with male wing extensions which is part of their courtship behavior. With this dataset we were particularly interested in whether our model could simulate a virtual fly in a complex, dynamic environment. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SynthFly is a synthetic dataset containing a single fly moving inside of a rectangular chamber with a stationary object located in the center. The fly is synthesized to move according to the control laws listed in Figure 2. The purpose of this dataset is to test whether our model could learn generative control rules, particularly ones that enforce non-deterministic behavior (see laws 4 and 5). ",
+        "bbox": [
+            174,
+            410,
+            823,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "IAM-OnDB (Liwicki & Bunke, 2005) contains handwritten text from 195 different writers, acquired using a smart whiteboard that records a list of (x, y) coordinates for each pen stroke. The data is weakly labeled, with each sequence separated into short lines of transcribed text. For consistency with our framework we hand annotated strokes of 10 writers, marking the start and end of the 26 lower case characters, which we use along with data from 35 unlabeled writers for our experiments. ",
+        "bbox": [
+            174,
+            473,
+            825,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All data, along with details about training and test splits, will be available in supplementary material. ",
+        "bbox": [
+            171,
+            549,
+            821,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "IAM-OnDB ",
+        "text_level": 1,
+        "bbox": [
+            643,
+            585,
+            714,
+            598
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/edb44f99f9043a58e041cc7e4c89c107a34c780fcf108bf58eacc0d3dee00cbb.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            585,
+            553,
+            743
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/93b3dff0bfaf4facff66b1d2039e823118aebff7174260f4fcc03bdad39911b1.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            565,
+            602,
+            818,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SynthFly - control laws: ",
+        "text_level": 1,
+        "bbox": [
+            604,
+            760,
+            751,
+            772
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/5b044416366f3fc00d29b298d6af8d2a88e4fd24b20c7533ed3bbad95221e757.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>total #frames</td><td rowspan=1 colspan=1>#trials</td><td rowspan=1 colspan=1>#agentsper trial</td><td rowspan=1 colspan=1>#labeledactions</td><td rowspan=1 colspan=1>total #instances</td><td rowspan=1 colspan=1>% frames</td></tr><tr><td rowspan=1 colspan=1>Fly-vs-Fly</td><td rowspan=1 colspan=1>3.7M</td><td rowspan=1 colspan=1>47</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>8599</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>FlyBowl</td><td rowspan=1 colspan=1>0.6M</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>961</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>SynthFly</td><td rowspan=1 colspan=1>0.4M</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0</td></tr><tr><td rowspan=1 colspan=1>IAM-OnDB*</td><td rowspan=1 colspan=1>1.5M</td><td rowspan=1 colspan=1>45</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>26</td><td rowspan=1 colspan=1>12049</td><td rowspan=1 colspan=1>88</td></tr></table>",
+        "bbox": [
+            174,
+            761,
+            535,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1) walk forward with random noise   \n2) at wall, rotate in direction of least resistance   \n3) when object in front visual field, walk towards it   \n4) extend either left or right wing (random)   \n5) at object, rotate left or right (alternating)   \n6) repeat 1) ",
+        "bbox": [
+            558,
+            776,
+            820,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2: Snapshots from the three labeled datsets used for our evaluation and a list of control laws used to generate synthetic fly trajectories. The table summarizes the statistics of each experimental dataset, where total # frames sums over all trials (videos / text documents) within an experiment and agents within a trial, total # instances sums over all action classes, and $\\%$ frames is the percent of frames in labeled sequences containing actions of interest. IAM-OnDB\\* is a subset of IAM-OnDB with additional annotations for 10 of its trials. ",
+        "bbox": [
+            173,
+            859,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d551afa184533b64e9762b219e8b1bf98c01276ba0f89494409c508623708fa.jpg",
+        "image_caption": [
+            "Figure 3: Left: Sensory input $v$ for fruit flies represents how a fly sees other flies and chamber walls, their motor control $_ x$ lets them move their body along 8 dimensions (incl. right wing ang/len). Right: Motor control $x$ for handwriting is represented as vector (dx, dy) along with binary stroke visibility $\\mathbf { Z }$ (pen on/off whiteboard). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            92,
+            823,
+            253
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fly representation: Motor control features, $x$ , describe the locomotion of a fly. The flies are tracked from video using FlyTracker2 and from the tracked fly poses we extract motion features represented in the fly’s frame of reference. The 8 motion features, displayed on top of the close-up fly3 in Figure 3, are designed such that they can animate virtual fly agents. Sensory input features, $v$ , are inspired by a fly’s compound eye which consist of 750 compactly aligned ommatidia. Approximating its vision as a one dimensional $3 6 0 ^ { \\circ }$ view, we place $7 2 5 ^ { \\circ }$ circular sectors around a fly agent, aligned with its orientation, and project flies that overlap with a sector onto its artificial retina with intensity inversely proportional to their distance to the agent. Thus, flies close to the agent yield high intensity in several pixels and flies that are far away take up few pixels with low intensity (compare scene in Figure 3 with $v$ sensed by the agent). We represent chamber walls similarly, projecting them onto a separate channel decreasing intensity exponentially with distance to the agent. This representation is invariant of the shape of the chamber and the number of flies present in the chamber. ",
+        "bbox": [
+            174,
+            323,
+            825,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to compare our model with methods presented in Eyjolfsdottir et al. (2014), independently of feature representation, we use the 36 features provided with the Fly-vs-Fly dataset. We assign the first 8 dimensions (describing fly’s motion) as motor control $x$ , and the remaining features (describing fly’s position relative to the other fly, and feature derivatives) as sensory input $v$ . ",
+        "bbox": [
+            174,
+            497,
+            823,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Handwriting representation: We represent the motor control, $x$ , as (dx, dy, z) where dx and dy are the x and y displacements from the previous pen recording and $\\mathbf { Z }$ is a binary variable denoting segment visibility. We normalize dx and dy for each writer, providing invariance to writing speed, but character size (number of points per character), slant, and other variations are not explicitly accounted for. As handwriting is not influenced by a changing environment, but rather a function of the internal state and current motion of the writer, we leave the sensory input, $v$ , empty. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            642
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            665,
+            455,
+            679
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our framework on three objectives: classification, simulation, and discovery. For classification we show the benefit of motion prediction as an auxiliary task, compare our performance on Fly-vs-Fly with previous work, and analyze the performance on IAM-OnDB. We qualitatively show that simulation results for fly behavior and handwriting look convincing, and that the model is able to learn control laws used to generate the SynthFly dataset. For discovery we show that hidden states of the model, trained only to predict motion (without any action labels), cleanly capture high level phenomena that affect behavior, such as fly gender and writer identity. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            794
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model details: We trained a separate model for each dataset, using a sequence length of 50, a batch size of 20, and 51 bins per dimension for motion prediction. For fly behavior data we used 2 levels of GRU cells (4 cells total) of 100 units each, and for handwriting we used 3 levels of GRU cells (6 cells total) of 200 units each. Parameters were determined using a rough parameter sweep on a subset of the training data. Further training details are described in supplementary material. Our model is implemented in Tensorflow (Abadi et al., 2015). ",
+        "bbox": [
+            174,
+            801,
+            825,
+            885
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "a) benefit of auxiliary task ",
+        "bbox": [
+            191,
+            92,
+            351,
+            103
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/63308561b782eeeff1123c91bbf8fa3c0c0a378d44ecebc3ba71c45eafa23d3f.jpg",
+        "table_caption": [
+            "b) Fly-vs-Fly comparison with prior work "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>F1 frame F1 bout</td><td></td><td>F*</td></tr><tr><td>hand crafting + windowSVM+ HMM</td><td>0.760</td><td>0.770</td><td>0.765</td></tr><tr><td>BENet</td><td>0.717</td><td>0.665</td><td>0.690</td></tr><tr><td>BENet + filter</td><td>0.716</td><td>0.739</td><td>0.727</td></tr><tr><td>BESNet</td><td>0.734</td><td>0.627</td><td>0.677</td></tr><tr><td>BESNet + filter</td><td>0.752</td><td>0.724</td><td>0.738</td></tr></table>",
+        "bbox": [
+            524,
+            108,
+            795,
+            210
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/08cc50ddfa9eb2302d406d2b269df3c0d7573a8bc0186c48acfdcb44a1c61412.jpg",
+        "image_caption": [
+            "Figure 4: a) Performance of model trained with (solid, BESNet) and without (dashed, BENet) motion prediction, showing that BESNet requires significantly fewer labels to match the performance of BENet. b) Our model reaches performance competitive with Eyjolfsdottir et al. (2014), without handcrafting or context from future frames. c) Input $x$ , label $y$ , and classification score $\\hat { y }$ , colored according to character label, showing high confusion at the beginning of characters, partly explaining the lower F1-frame performance on IAM-OnDB. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            108,
+            495,
+            335
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "c) IAM-OnDB example ",
+        "text_level": 1,
+        "bbox": [
+            521,
+            223,
+            663,
+            234
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/947cbe53d030058ac0feed431ce63a3ff067627bb0db24994807f5151a7428f7.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            237,
+            797,
+            335
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            331,
+            445
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Action labeling involves recording the start frame, end frame, and class label, of each action interval, which we refer to as a bout. From a sequence of frame-wise classifications, consecutive frames of the same class prediction are consolidated into a single bout. To measure both duration and counting accuracy we use the performance measures described in Eyjolfsdottir et al. (2014), namely the F1 score (harmonic mean of precision and recall), on a per-frame and per-bout level. Bout-wise precision and recall is computed by assigning predicted bouts to ground truth bouts one-to-one, maximizing intersection over overlap. $\\mathrm { F ^ { * } }$ is the harmonic mean of the F1-frame and F1-bout scores. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            555
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our goal for classification is to reduce the number of training labels without loss in performance. To measure the benefit of motion prediction as an auxiliary task we compare our model, which we will refer to as Behavior Embedding Sensory-motor Network (BESNet), with our model without its generative part (similar to a standard RNN but with action labels embedded in hidden states, shown in Figure 5), referred to as Behavior Embedding Network (BENet). We trained both models on each dataset using $3 \\mathrm { - } 1 0 0 \\%$ of available labels. As BESNet is trained to predict future motion it makes use of unlabeled sequences during training whereas BENet does not. Figure 4 a) shows the frame-wise F1 score for each of the 36 trained models (3 datasets, 6 label fractions, 2 model types), averaged over all action classes in a dataset. This experiment shows that motion prediction as an auxiliary task significantly improves classification performance, especially when labels are scarce. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            702
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Figure $^ { 4 \\mathrm { ~ b ~ } }$ ) we compare the performance of our network with the best performing method on Flyvs-Fly, a window based support vector machine (SVM) that uses hand crafted window features and fits an HMM to the output for smoother classification – outperforming sophisticated methods such as structured SVM. For this comparison we used the features published with the dataset as described in Section 4. Although recurrent networks implicitly enable smooth classification, different actions require different levels of smoothness. To avoid over segmentation of action intervals, we smooth the output of our network by applying a flat filter, of size equal to $10 \\%$ of the mean duration of each class. Our results show that filtering significantly improves the bout-wise performance and that our performance on the Fly-vs-Fly test set is comparable with that of Eyjolfsdottir et al. (2014), using no handcrafting and no context of future frames (apart from smoothing). ",
+        "bbox": [
+            174,
+            708,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We applied the same type of filtering to the classification output of IAM-OnDB as we did for Flyvs-Fly and obtained an F1-(frame, bout) of (0.445, 0.585) averaged over all classes, and (0.567, 0.690) averaged over all instances (weighted average of classes). Figure $4 \\mathrm { ~ c ~ }$ ) demonstrates that at the beginning of some characters there tends to be more confusion in $\\hat { y }$ than towards the end, which is unsurprising as the beginning of these characters looks approximately the same. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 MOTION PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            362,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Before we look at simulation results, we quantitatively measure the accuracy of one-step predictions. We compute the log-likelihood of FlyBowl test sequences under the motion prediction model: $\\begin{array} { r } { \\mathrm { l o g l i k } ( x ) = { \\bar { \\sum _ { i = 1 } ^ { T - 1 } } } \\sum _ { d = 1 } ^ { 8 } \\log \\left( { \\tilde { x } _ { i + 1 } ^ { d } } \\cdot { \\hat { x } _ { i + 1 } ^ { d } } \\right) } \\end{array}$ , where $\\tilde { x } _ { i + 1 } ^ { d }$ is the ground truth indicator vector for bins of motion dimension $d$ , and $\\hat { x } _ { i + 1 } ^ { d }$ is a probability distribution over the bins predicted by the model. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            193
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare our model with the following motion prediction policies: 1) uniform distribution over bins, 2) distribution over bins computed from training set, 3) constant motion policy that copies previous indicator vector as motion prediction, and 4) a smooth version of 3) filtered using an optimized Gaussian kernel. The results, shown in Figure 5, demonstrate that the recurrent models learn a significantly better policy. In addition, we compare variants of our model and a standard RNN within our framework (with the same sensory-motor representation, multimodal output, and GRU cells) which shows that recurrence is essential for good motion prediction and that diagonal connections provide a slight performance gain. In Section 5.4 we show the main benefit of the diagonals. ",
+        "bbox": [
+            173,
+            198,
+            825,
+            310
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "a) network variants ",
+        "bbox": [
+            176,
+            321,
+            303,
+            335
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/6122d23e292ada2f9718073ff6e41343732ee6fba496e43b45bb24dce1c0157e.jpg",
+        "image_caption": [
+            "Figure 5: a) Network variants used in experiments (compare BESNet to highlighted cells in its unrolled visualization in Figure 1). b) 1-step motion prediction performance on FlyBowl testset, see text above for explanation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            342,
+            821,
+            465
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 SIMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            527,
+            303,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "xi  i One-step prediction performance does not clearly reveal whether a model has learnt the generative L( , ) = sum_f(crossentropy ( , ) xf i+1 \\~ xf i+1 ^ xi+1 xi+1^process underlying the training data. In order to get a better notion of that we look at simulations produced by the learnt models, which can be thought of as very long term predictions. As motion 1xi \\~ fground truthprediction is probabilistic, comparing long term predictions with ground truth becomes difficult as ^the domain of probable positions becomes exponentially large. Qualitative inspection, however, x      i gives a good intuition about whether the simulated agent has learnt reasonable control laws. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While the underlying generative process for the motion of real flies is unknown, simulations from the model trained to imitate them suggest that the model has learnt a reasonable policy. During simulation we place no physical constraints on how the flies can move but our results show that simulated FlyBowl agents avoid collisions with the chamber walls and with other flies, and that agents are attracted to other flies and occasionally engage in courtship-like behavior. This is shown in Figure 6 and better visualized as video in supplementary material. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Simulated handwriting is easier to visualize in an image and we are used to recognizing the structure it should produce. Figure 7 shows that the model trained on IAM-OnDB produces character-like trajectories in word-like combinations. Note that handwriting is generated one (dx, dy, z) vector at a time, and each character is composed of roughly 20 such points on average. On the right hand side of Figure 7 we show that we can increase the generation of specific characters by activating their classification units (forcing their values to 1 and others to 0) during simulation. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 8 shows the output of two recurrent units of the SynthFly model that indicate that the model was able to learn control rules that were designed to ensure a multimodal motion prediction target. One unit fires in correlation with either left or right wing extension, and the other toggles between a negative and positive state as the agent turns left or right to avoid the object. In supplementary material we show a video of this simulation and compare it to a simulation from the model trained with deterministic motion prediction. This comparison clearly demonstrates the benefit of treating motion prediction as a distribution over bins, as the deterministic agent quickly becomes degenerate. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/bdc4ebe3a762a85ec23da17e615604be7192cc6a4286f710de08165a46cfed82.jpg",
+        "image_caption": [
+            "Figure 6: a) $1 0 \\mathrm { ~ x ~ } 2 0$ -frame lookaheads (simulations) for each test fly from its current location, demonstrating the non-deterministic nature of the motion prediction. The ground truth 20-frame future trajectory is outlined in black for comparison. b) shows trajectories of 20 flies simulated for 1000 frames, and c) shows 1000-frame trajectories for 20 real flies interacting. The simulation shows that the model has learnt a preference for staying near the boundary and to avoid walking through the boundary. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            825,
+            257
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/416b74bfcbf5d01bcf21d4dd8a217f057019397ebe4af0b863ca126cad460643.jpg",
+        "image_caption": [
+            "Figure 7: Left: Text generated by our model, one vector at a time (approximately 20 vectors per character). Right: Text generated by the same model while ”activating” character classification units of the model during simulation, shown in two lines per character. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            354,
+            818,
+            508
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/0501a2c84e7c8147b2909c69de0e18e50cd4367858626bafb09585cc17d850a2.jpg",
+        "image_caption": [
+            "r l r l l l l l r lr l r l l l l l r lFigure 8: Comparison between synthetic fly (ground truth) and simulation by our model. The wing angles, distance to object, and left/right turn show the agent’s motion over time, and the two hidden units indicate that the model has learnt to represent control laws 4 and 5 used to generate the synthetic trajectories. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            578,
+            826,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 DISCOVERY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            795,
+            297,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We motivated the structure of our network, specifically the diagonal connections between discriminative and generative cells, with the intuition that it would allow higher levels of the network to better represent high level phenomena. To verify this we train models to only predict future motion, with no classification target, and visualize what the hidden states capture. We apply the model to $[ x , v ]$ , obtaining hidden state vectors $h ^ { l }$ and $\\hat { h } ^ { l }$ , $l \\in \\{ 1 , . . . , L \\}$ , and prediction $\\hat { x }$ , map the data points (time steps of each fly/writer) from each state to 2 dimensions using t-distributed stochastic neighbor embedding (tSNE, Maaten & Hinton (2008)), and plot them in colors based on known phenomena. ",
+        "bbox": [
+            173,
+            824,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/c2db86514d23a0e71c2f7e8bdb56bbc226676c462e4a36af2b63e733b6e74657.jpg",
+        "image_caption": [
+            "Figure 9: Left: Hidden state values of a 3 level model trained without any labels on IAM-OnDB, reduced to 2 dimensions using tSNE mapping. The network discovers writer identity at the highest level, while lower level phenomena such as stroke length are represented at lower levels. Right: tSNE mapped input, output, and hidden state values of FlyBowl model (trained without any labels), colored by gender and male wing extension. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            93,
+            816,
+            292
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Figure 9 we plot the data points of a 3 level $( \\mathrm { L } { = } 3 )$ ) model trained on IAM-OnDB in this low dimensional embedding, and color code them according to three criteria: stroke length, character class, and writer identity. The results show that stroke length is well clustered at low levels but not at high levels, characters are best clustered at mid to top discriminative levels, and writer identity is extremely well clustered at the top generative level but not at low levels. We ran the same experiment for the model trained without diagonal connections (which without a classification target is effectively a standard RNN with 6 levels of GRU cells), which did not learn to represent writer identity in any of its hidden states. Intuitively this is because the network has to carry low level information through every state to predict low level information at the other end, whereas BESNet carries it directly through the low level diagonal connections leaving higher hidden states free to capture high level information. A visualization comparing both models is shown in supplementary material along with a quantitative measurement of our observation. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            542
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The same visualization for the model trained on FlyBowl, where data points are color coded by gender and left/right wing extension, shows (Figure 9, right) that gender is very mixed in the input and output states but well separated in the top generative state, while lower level information such as wing extension is well represented at lower levels of the network. ",
+        "bbox": [
+            174,
+            550,
+            823,
+            606
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            318,
+            642
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have proposed a framework for modeling the behavior of animals, that simultaneously classifies their actions and predicts their motion. We showed empirically that motion prediction (a target that requires no labeling) is a good auxiliary task for training action classifiers, especially when labels are scarce. We also showed that the generative task can be used to simulate trajectories that look natural to the human eye, and that activating classification units increases the frequency of that action in the simulation. Finally, we showed that our model lends itself well to discovery of high level information from the data, by visualizing what is captured in its hidden states. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We tested the framework on two types of data, fly behavior and online handwriting, and we anticipate that it will scale to more complex data with appropriate tuning of hyperparameters and abstraction of visual input. For example, application to human motion capture with 1st person video as sensory input might require greater model complexity to account for the higher dimensional motor control and pre-processing of the sensory input, e.g. with a convolutional neural network, to extract a higher level sensory representation before feeding it to the dynamical system. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Moving forward, we are interested in working on hierarchical label embedding in the states, assigning higher order activities to units higher in the network. Along those lines, a discrete recurrent network could be trained separately on the wealth of available text, and be placed on top of a realvalued handwriting network. We also aim to explore how this framework can be used to understand the neural mechanisms underlying the generation of behavior in flies. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            387,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank David J. Anderson and Charless Fowlkes for insightful discussions, and acknowledge Google and The Simons Foundation for their financial support. ",
+        "bbox": [
+            173,
+            133,
+            823,
+            161
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            181,
+            285,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´ Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´ berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org. ",
+        "bbox": [
+            176,
+            205,
+            825,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David J Anderson and Pietro Perona. Toward a science of computational ethology. Neuron, 84(1): 18–31, 2014. ",
+        "bbox": [
+            171,
+            339,
+            821,
+            368
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pierre Baldi. Autoencoders, unsupervised learning, and deep architectures. ICML unsupervised and transfer learning, 27(37-50):1, 2012. ",
+        "bbox": [
+            171,
+            376,
+            825,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gordon J Berman, Daniel M Choi, William Bialek, and Joshua W Shaevitz. Mapping the stereotyped behaviour of freely moving fruit flies. Journal of The Royal Society Interface, 11(99):20140672, 2014. ",
+        "bbox": [
+            174,
+            412,
+            826,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Valentino Braitenberg. Vehicles Experiments in Synthetic Psychology. MIT Press, 1984. ",
+        "bbox": [
+            171,
+            463,
+            751,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xavier P Burgos-Artizzu, Piotr Dollar, Dayu Lin, David J Anderson, and Pietro Perona. Social ´ behavior recognition in continuous video. In Computer Vision and Pattern Recognition (CVPR), 2012 IEEE Conference on, pp. 1322–1329. IEEE, 2012. ",
+        "bbox": [
+            173,
+            487,
+            826,
+            530
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder-decoder for statistical machine translation. arXiv preprint arXiv:1406.1078, 2014. ",
+        "bbox": [
+            173,
+            537,
+            825,
+            582
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Kyle Kastner, Laurent Dinh, Kratarth Goel, Aaron C Courville, and Yoshua Bengio. A recurrent latent variable model for sequential data. In Advances in neural information processing systems, pp. 2962–2970, 2015. ",
+        "bbox": [
+            173,
+            589,
+            823,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anthony I Dell, John A Bender, Kristin Branson, Iain D Couzin, Gonzalo G de Polavieja, Lucas PJJ Noldus, Alfonso Perez-Escudero, Pietro Perona, Andrew D Straw, Martin Wikelski, et al. Auto- ´ mated image-based tracking and its application in ecology. Trends in ecology & evolution, 29(7): 417–428, 2014. ",
+        "bbox": [
+            173,
+            640,
+            825,
+            696
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Eyrun Eyjolfsdottir, Steve Branson, Xavier P Burgos-Artizzu, Eric D Hoopfer, Jonathan Schor, David J Anderson, and Pietro Perona. Detecting social actions of fruit flies. In Computer Vision– ECCV 2014, pp. 772–787. Springer, 2014. ",
+        "bbox": [
+            176,
+            705,
+            823,
+            748
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alan Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on, pp. 6645–6649. IEEE, 2013. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            799
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013. ",
+        "bbox": [
+            173,
+            808,
+            823,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            844,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hueihan Jhuang, Estibaliz Garrote, Xinlin Yu, Vinita Khilnani, Tomaso Poggio, Andrew D Steele, and Thomas Serre. Automated home-cage behavioural phenotyping of mice. Nature communications, 1:68, 2010. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mayank Kabra, Alice A Robie, Marta Rivera-Alba, Steven Branson, and Kristin Branson. Jaaba: interactive machine learning for automatic annotation of animal behavior. nature methods, 10(1): 64–67, 2013. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marcus Liwicki and Horst Bunke. Iam-ondb-an on-line english sentence database acquired from handwritten text on a whiteboard. In Document Analysis and Recognition, 2005. Proceedings. Eighth International Conference on, pp. 956–961. IEEE, 2005. ",
+        "bbox": [
+            173,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Laurens van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of Machine Learning Research, 9(Nov):2579–2605, 2008. ",
+        "bbox": [
+            171,
+            207,
+            825,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            173,
+            243,
+            826,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J Moore. Some thoughts on the relation between behavior analysis and behavioral neuroscience. The Psychological Record, 52(3):261, 2002. ",
+        "bbox": [
+            173,
+            295,
+            821,
+            325
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kevin Patrick Murphy. Dynamic bayesian networks: representation, inference and learning. PhD thesis, University of California, Berkeley, 2002. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Antti Rasmus, Mathias Berglund, Mikko Honkala, Harri Valpola, and Tapani Raiko. Semisupervised learning with ladder networks. In Advances in Neural Information Processing Systems, pp. 3532–3540, 2015. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "William M Roberts, Steven B Augustine, Kristy J Lawton, Theodore H Lindsay, Tod R Thiele, Eduardo J Izquierdo, Serge Faumont, Rebecca A Lindsay, Matthew Cale Britton, Navin Pokala, et al. A stochastic neuronal model predicts random search behaviors at multiple spatial scales in c. elegans. eLife, 5:e12572, 2016. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            479
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "DE Rumenlhart, Geoffrey E Hinton, and Ronald J Williams. Learning internal representation by error propagation, parallel distributed processing. Explor. Microstruct. Cognition, 1:318–362, 1986. ",
+        "bbox": [
+            173,
+            488,
+            825,
+            530
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            176,
+            539,
+            823,
+            583
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Herbert A Simon. The sciences of the artificial. MIT press, 1996. ",
+        "bbox": [
+            173,
+            592,
+            604,
+            607
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kathleen K Siwicki and Edward A Kravitz. Fruitless, doublesex and the genetics of social behavior in drosophila melanogaster. Current opinion in neurobiology, 19(2):200–206, 2009. ",
+        "bbox": [
+            173,
+            614,
+            823,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Niko Tinbergen. On aims and methods of ethology. Zeitschrift fur Tierpsychologie ¨ , 20(4):410–433, 1963. ",
+        "bbox": [
+            173,
+            652,
+            823,
+            683
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Harri Valpola. From neural pca to deep unsupervised learning. Adv. in Independent Component Analysis and Learning Machines, pp. 143–171, 2015. ",
+        "bbox": [
+            171,
+            690,
+            825,
+            720
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander B Wiltschko, Matthew J Johnson, Giuliano Iurilli, Ralph E Peterson, Jesse M Katon, Stan L Pashkovski, Victoria E Abraira, Ryan P Adams, and Sandeep Robert Datta. Mapping sub-second structure in mouse behavior. Neuron, 88(6):1121–1135, 2015. ",
+        "bbox": [
+            176,
+            728,
+            825,
+            772
+        ],
+        "page_idx": 11
+    }
+]

parse/train/IMPnRXEWpvr/IMPnRXEWpvr.md

@@ -0,0 +1,487 @@
+# TOWARDS IMPARTIAL MULTI-TASK LEARNING
+
+Liyang $\mathbf { L i u } ^ { 1 }$ , Yi $\mathbf { L i } ^ { 2 }$ , Zhanghui Kuang2, Jing-Hao Xue3, Yimin Chen2, Wenming Yang1∗, Qingmin Liao1, Wayne Zhang2,4
+
+1Shenzhen International Graduate School/Department of   
+Electronic Engineering, Tsinghua University   
+2SenseTime Research   
+3Department of Statistical Science, University College London   
+4Qing Yuan Research Institute, Shanghai Jiao Tong University   
+{liu-ly14@mails., yang.wenming@sz., liaoqm@}tsinghua.edu.cn   
+{liyi, kuangzhanghui, chenyimin, wayne.zhang}@sensetime.com   
+jinghao.xue@ucl.ac.uk
+
+# ABSTRACT
+
+Multi-task learning (MTL) has been widely used in representation learning. However, na¨ıvely training all tasks simultaneously may lead to the partial training issue, where specific tasks are trained more adequately than others. In this paper, we propose to learn multiple tasks impartially. Specifically, for the task-shared parameters, we optimize the scaling factors via a closed-form solution, such that the aggregated gradient (sum of raw gradients weighted by the scaling factors) has equal projections onto individual tasks. For the task-specific parameters, we dynamically weigh the task losses so that all of them are kept at a comparable scale. Further, we find the above gradient balance and loss balance are complementary and thus propose a hybrid balance method to further improve the performance. Our impartial multi-task learning (IMTL) can be end-to-end trained without any heuristic hyper-parameter tuning, and is general to be applied on all kinds of losses without any distribution assumption. Moreover, our IMTL can converge to similar results even when the task losses are designed to have different scales, and thus it is scale-invariant. We extensively evaluate our IMTL on the standard MTL benchmarks including Cityscapes, NYUv2 and CelebA. It outperforms existing loss weighting methods under the same experimental settings.
+
+# 1 INTRODUCTION
+
+Recent deep networks in computer vision can match or even surpass human beings on some specific tasks separately. However, in reality multiple tasks (e.g., semantic segmentation and depth estimation) must be solved simultaneously. Multi-task learning (MTL) (Caruana, 1997; Evgeniou & Pontil, 2004; Ruder, 2017; Zhang & Yang, 2017) aims at sharing the learned representation among tasks (Zamir et al., 2018) to make them benefit from each other and achieve better results and stronger robustness (Zamir et al., 2020). However, sharing the representation can lead to a partial learning issue: some specific tasks are learned well while others are overlooked, due to the different loss scales or gradient magnitudes of various tasks and the mutual competition among them. Several methods have been proposed to mitigate this issue either via gradient balance such as gradient magnitude normalization (Chen et al., 2018) and Pareto optimality (Sener & Koltun, 2018), or loss balance like homoscedastic uncertainty (Kendall et al., 2018). Gradient balance can evenly learn task-shared parameters while ignoring task-specific ones. Loss balance can prevent MTL from being biased in favor of tasks with large loss scales but cannot ensure the impartial learning of the shared parameters. In this work, we find that gradient balance and loss balance are complementary, and combining the two balances can further improve the results. To this end, we propose impartial MTL (IMTL) via simultaneously balancing gradients and losses across tasks.
+
+For gradient balance, we propose IMTL-G(rad) to learn the scaling factors such that the aggregated gradient of task-shared parameters has equal projections onto the raw gradients of individual tasks (see Fig. 1 (d)). We show that the scaling factor optimization problem is equivalent to finding the angle bisector of gradients from all tasks in geometry, and derive a closed-form solution to it. In contrast with previous gradient balance methods such as GradNorm (Chen et al., 2018), MGDA (Sener & Koltun, 2018) and PCGrad (Yu et al., 2020), which have learning biases in favor of tasks with gradients close to the average gradient direction, those with small gradient magnitudes, and those with large gradient magnitudes, respectively (see Fig. 1 (a), (b) and (c)), in our IMTL-G task-shared parameters can be updated without bias to any task.
+
+![](images/930ecf2f150430e547efaf93211118a568b2d614aa0dbcec03474a189e1e23a9.jpg)  
+Figure 1: Comparison of gradient balance methods. In (a) to (d), ${ \bf g } _ { 1 } , { \bf g } _ { 2 }$ and $\mathbf { \pmb { g } } _ { 3 }$ represent the gradient computed by the raw loss of each task, respectively. The gray surface represents the plane composed by these gradients. The red arrow denotes the aggregated gradient computed by the weighted sum loss, which is ultimately used to update the model parameters. The blue arrows show the projections of $\pmb { g }$ onto the raw gradients $\left\{ \pmb { g } _ { t } \right\}$ . $\pmb { g }$ has the largest projection on $\pmb { g } _ { 2 }$ (nearest to the mean direction), $\mathbf { \pmb { g } } \mathbf { 3 }$ (smallest magnitude) and $\mathbf { \delta } \mathbf { \ } \mathbf { \mathcal { g } } _ { 2 }$ (largest magnitude) for GradNorm, MGDA and PCGrad, respectively, while the projections are equal on $\left\{ \pmb { g } _ { t } \right\}$ in our IMTL-G.
+
+For loss balance, we propose IMTL-L(oss) to automatically learn a loss weighting parameter for each task so that the weighted losses have comparable scales and the effect of different loss scales from various tasks can be canceled-out. Compared with uncertainty weighting (Kendall et al., 2018), which has biases towards regression tasks rather than classification tasks, our IMTL-L treats all tasks equivalently without any bias. Besides, we model the loss balance problem from the optimization perspective without any distribution assumption that is required by (Kendall et al., 2018). Therefore, ours is more general and can be used in any kinds of losses. Moreover, the loss weighting parameters and the network parameters can be jointly learned in an end-to-end fashion in IMTL-L.
+
+Further, we find the above two balances are complementary and can be combined to improve the performance. Specifically, we apply IMTL-G on the task-shared parameters and IMTL-L on the task-specific parameters, leading to the hybrid balance method IMTL. Our IMTL is scale-invariant: the model can converge to similar results even when the same task is designed to have different loss scales, which is common in practice. For example, the scale of the cross-entropy loss in semantic segmentation may have different scales when using “average” or “sum” reduction over locations in the loss computation. We empirically validate that our IMTL is more robust against heavy loss scale changes than its competitors. Meanwhile, our IMTL only adds negligible computational overheads.
+
+We extensively evaluate our proposed IMTL on standard benchmarks: Cityscapes, NYUv2 and CelebA, where the experimental results show that IMTL achieves superior performances under all settings. Besides, considering there lacks a fair and practical benchmark for comparing MTL methods, we unify the experimental settings such as image resolution, data augmentation, network structure, learning rate and optimizer option. We re-implement and compare with the representative MTL methods in a unified framework, which will be publicly available. Our contributions are:
+
+• We propose a novel closed-form gradient balance method, which learns task-shared parameters without any task bias; and we develop a general learnable loss balance method, where no distribution assumption is required and the scale parameters can be jointly trained with the network parameters.   
+We unveil that gradient balance and loss balance are complementary and accordingly propose a hybrid balance method to simultaneously balance gradients and losses.   
+We validate that our proposed IMTL is loss scale-invariant and is more robust against loss scale changes compared with its competitors, and we give in-depth theoretical and experimental analyses on its connections and differences with previous methods.   
+We extensively verify the effectiveness of our IMTL. For fair comparisons, a unified codebase will also be publicly available, where more practical settings are adopted and stronger performances are achieved compared with existing code-bases.
+
+# 2 RELATED WORK
+
+Recent advances in MTL mainly come from two aspects: network structure improvements and loss weighting developments. Network-structure methods based on soft parameter-sharing usually lead to high inference cost (review in Appendix A). Loss weighting methods find loss weights to be multiplied on the raw losses for model optimization. They employ a hard parameter-sharing paradigm (Ruder, 2017), where several light-weight task-specific heads are attached upon the heavy-weight task-agnostic backbone. There are also efforts that learn to group tasks and branch the network in the middle layers (Guo et al., 2020; Standley et al., 2020), which try to achieve better accuracyefficiency trade-off and can be seen as semi-hard parameter-sharing. We believe task grouping and loss weighting are orthogonal and complementary directions to facilitate multi-task learning and can benefit from each other. In this work we focus on loss weighting methods which are the most economic as almost all of the computations are shared across tasks, leading to high inference speed. Task Prioritization (Guo et al., 2018) weights task losses by their difficulties to focus on the harder tasks during training. Uncertainty weighting (Kendall et al., 2018) models the loss weights as dataagnostic task-dependent homoscedastic uncertainty. Then loss weighting is derived from maximum likelihood estimation. GradNorm (Chen et al., 2018) learns the loss weights to enforce the norm of the scaled gradient for each task to be close. MGDA (Sener & Koltun, 2018) casts multi-task learning as multi-object optimization and finds the minimum-norm point in the convex hull composed by the gradients of multiple tasks. Pareto optimality is supposed to be achieved under mild conditions. GLS (Chennupati et al., 2019) instead uses the geometric mean of task-specific losses as the target loss, we will show it actually weights the loss by its reciprocal value. PCGrad (Yu et al., 2020) avoids interferences between tasks by projecting the gradient of one task onto the normal plane of the other. DSG (Lu et al., 2020) dynamically makes a task “stop or go” by its converging state, where a task is updated only once for a while if it is stopped. Although many loss weighting methods have been proposed, they are seldom open-sourced and rarely compared thoroughly under practical settings where strong performances are achieved, which motivates us to give an in-depth analysis and a fair comparison about them.
+
+# 3 IMPARTIAL MULTI-TASK LEARNING
+
+In MTL, we map a sample $\pmb { x } \in \mathbb { X }$ to its labels $\{ y _ { t } \in \mathbb { Y } _ { t } \} _ { t \in [ 1 , T ] }$ of all $T$ tasks through multiple taskspecific mappings $\{ f _ { t } : \mathbb { X } \to \mathbb { Y } _ { t } \}$ . In most loss weighting methods, the hard parameter-sharing paradigm is employed, such that $\pmb { f } _ { t }$ is parameterized by heavy-weight task-shared parameters $\pmb \theta$ and light-weight task-specific parameters $\theta _ { t }$ . All tasks take the same shared intermediate feature ${ z } = { f } \left( { { x } ; \theta } \right)$ as input, and the $t$ -th task head outputs the prediction as ${ \pmb f } _ { t } \left( \pmb { x } \right) = { \pmb f } _ { t } \left( \pmb { z } ; { \pmb \theta } _ { t } \right)$ . We aim to find the scaling factors $\left\{ \alpha _ { t } \right\}$ for all $T$ task losses $\{ \bar { L _ { t } } \left( \pmb { f } _ { t } \left( \pmb { x } \right) , \pmb { y } _ { t } \right) \}$ , so that the weighted sum loss $\begin{array} { r } { L = \sum _ { t } \alpha _ { t } \bar { L } _ { t } } \end{array}$ can be optimized to make all tasks perform well. This poses great challenges because: 1) losses may have distinguished forms such as cross-entropy loss and cosine similarity; 2) the dynamic ranges of losses may differ by orders of magnitude. In this work, we propose a hybrid solution for both the task-shared parameters $\pmb \theta$ and the task-specific parameters $\{ \pmb \theta _ { t } \}$ , as Fig. 2.
+
+# 3.1 GRADIENT BALANCE: IMTL-G
+
+For task-shared parameters $\pmb \theta$ , we can receive $T$ gradients $\{ g _ { t } = \nabla _ { \theta } L _ { t } \}$ via back-propagation from all of the $T$ raw losses $\{ L _ { t } \}$ , and these gradients represent optimal update directions for individual tasks. As the parameters $\pmb { \theta }$ can only be updated with a single gradient, we should compute an aggregated gradient $\textbf {  { g } }$ by the linear combination of $\left\{ \pmb { g } _ { t } \right\}$ . It also implies to find the scaling factors $\left\{ \alpha _ { t } \right\}$ of raw losses $\{ L _ { t } \}$ , since $\begin{array} { r } { \pmb { g } = \sum _ { t } ^ { } \alpha _ { t } \pmb { g } _ { t } = \dot { \nabla } \pmb { \theta } \dot { L } = \nabla _ { \pmb { \theta } } \left( \sum _ { t } \dot { \alpha _ { t } } L _ { t } \right) } \end{array}$ Motivated by the principle of balance among tasks, we propose to make the projections of $\textbf {  { g } }$ onto $\left\{ \pmb { g } _ { t } \right\}$ to be equal, as Fig. 1 (d). In this way,
+
+![](images/1836064a7a62a4bc9a4d59b61005bd96527af8b554f334b9de43f7bb8947cef9.jpg)  
+Figure 2: Overview of IMTL.
+
+Algorithm 1 Training by Impartial Multi-task Learning   
+
+<table><tr><td>Input:input sample x,task-specific labels {yt} and learning rate n Output: task-shared/-specific parameters 0/{0t},scale parameters {st }</td><td></td><td></td><td></td><td></td></tr><tr><td>1: compute task-shared feature z = f (x; 0) 2:for t=1to Tdo compute task prediction by head network ft (x) = fnet (z; 0t)</td><td></td><td></td><td></td><td></td></tr><tr><td>3: 4:</td><td>compute raw loss by loss function Lraw</td><td>=Lfunc（ft(x）,yt)</td><td></td><td></td></tr><tr><td>5:</td><td>compute scaled lossLt = bast Lraw- St (default a = e,b= 1)</td><td></td><td></td><td>loss balance</td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>6:</td><td>compute gradient of shared feature z: gt = VzLt</td><td></td><td></td><td></td></tr><tr><td>7:</td><td>compute unit-norm gradient Ut = gt gt1</td><td></td><td></td><td></td></tr><tr><td>8:end for</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>9: compute gradient differences DT= [gI -g,··,gT -gT]</td><td></td><td></td><td></td></tr><tr><td></td><td>10: compute unit-norm gradient differences UT=[u-u,,ul-uT]</td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>11: compute scaling factors for tasks 2 to T: α2:T = g1UT (DUT)-1</td><td></td><td></td><td> gradient balance</td></tr><tr><td></td><td>12: compute scaling factors for all tasks: α =［1-1α2:T，(</td><td></td><td>α2:T]</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>13: update task-shared parameters 0 = 0 - nVe (∑t αtLt)</td><td></td><td></td><td></td></tr><tr><td>14:for t=1 to Tdo</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>15:update task-specific parameters 0t = 0t - nVet Lt</td><td></td><td></td><td></td></tr><tr><td></td><td>16:update loss scale parameter St = St - nst</td><td>aLt</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td>17: end for</td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td></tr></table>
+
+we treat all tasks equally so that they progress in the same speed and none is left behind. Formally, let $\{ \pmb { u } _ { t } = \pmb { g } _ { t } / \left| \left| \pmb { g } _ { t } \right| \right| \}$ denote the unit-norm vector of $\left\{ \pmb { g } _ { t } \right\}$ which are row vectors, then we have:
+
+$$
+g \pmb { u } _ { 1 } ^ { \top } = \pmb { g } \pmb { u } _ { t } ^ { \top } \Leftrightarrow \pmb { g } \left( \pmb { u } _ { 1 } - \pmb { u } _ { t } \right) ^ { \top } = 0 , \forall 2 \leqslant t \leqslant T .
+$$
+
+The above problem is under-determined, but we can obtain the closed-form results of $\{ \alpha _ { t } \}$ by constraining $\textstyle \sum _ { t } \alpha _ { t } \ = \ 1$ . Assume ${ \pmb { \alpha } } ~ = ~ [ \alpha _ { 2 } , \cdot \cdot \cdot , \alpha _ { T } ]$ , $\pmb { U } ^ { \top } ~ = ~ \left[ \pmb { u } _ { 1 } ^ { \top } - \pmb { u } _ { 2 } ^ { \top } , \cdot \cdot \cdot , \pmb { u } _ { 1 } ^ { \top } - \pmb { u } _ { T } ^ { \top } \right]$ , $\pmb { { \cal D } } ^ { \top } = \left[ \pmb { { \mathscr { g } } } _ { 1 } ^ { \top } - \pmb { { \mathscr { g } } } _ { 2 } ^ { \top } , \cdots , \pmb { { \mathscr { g } } } _ { 1 } ^ { \top } - \pmb { { \mathscr { g } } } _ { T } ^ { \top } \right]$ and $\mathbf { 1 } = [ 1 , \cdots , 1 ]$ , from Eq. (1) we can obtain:
+
+$$
+\begin{array} { r } { { \pmb { \alpha } } = { \pmb { g } } _ { 1 } { \pmb { U } } ^ { \top } \left( { \pmb { D } } { \pmb { U } } ^ { \top } \right) ^ { - 1 } . \qquad ( \mathrm { I M T L - G ) } } \end{array}
+$$
+
+The detailed derivation is in Appendix B.1. After obtaining $_ { \pmb { \alpha } }$ , the scaling factor of the first task can be computed by $\alpha _ { 1 } = 1 - 1 \stackrel { . } { \alpha } ^ { \top }$ since $\textstyle \sum _ { t } \alpha _ { t } = 1$ . The optimized $\left\{ \alpha _ { t } \right\}$ are used to compute $L =$ $\sum _ { t } \alpha _ { t } \bar { L _ { t } }$ , which is ultimately minimized by SGD to update the model. By now, back-propagation needs to be executed $T$ times to obtain the gradient of each task loss with respect to the heavy-weight task-shared parameters $\pmb { \theta }$ , which is time-consuming and non-scalable. We replace the parameterlevel gradients $\{ g _ { t } = \nabla _ { \theta } L _ { t } \}$ with feature-level gradients $\{ \nabla _ { z } L _ { t } \}$ to compute $\left\{ \alpha _ { t } \right\}$ . This implies to achieve gradient balance with respect to the last shared feature $_ z$ as a surrogate of task-shared parameters $\pmb \theta$ , since it is possible for the network to back-propagate this balance all the way through the task-shared backbone starting from $_ z$ . This relaxation allows us to do back propagation through the backbone only once after obtaining $\{ \alpha _ { t } \}$ , and thus the training time can be dramatically reduced.
+
+# 3.2 LOSS BALANCE: IMTL-L
+
+For the task-specific parameters $\{ \pmb \theta _ { t } \}$ , we cannot employ IMTL-G described above, because $\nabla _ { \pmb { \theta } _ { t } } L _ { \tau } = \mathbf { 0 } , \forall t \neq \tau$ , and thus only the gradient of the corresponding task $\nabla _ { \pmb { \theta } _ { t } } L _ { t }$ can be obtained for each $\theta _ { t }$ . Instead we propose to balance the losses among tasks by forcing the scaled losses $\left\{ \alpha _ { t } L _ { t } \right\}$ to be constant for all tasks, without loss of generality, we take the constant as 1. Then the most direct idea is to compute the scaling factors as $\{ \alpha _ { t } = 1 / L _ { t } \}$ , but they are sensitive to outlier samples and manifest severe oscillations, so we further propose to learn to scale losses via gradient descent and thus stronger stability can be achieved. Suppose the positive losses $\{ L _ { t } > 0 \}$ are to be balanced, we first introduce a mapping function $h : \mathbb { R } \stackrel { } { \to } \mathbb { R } ^ { + }$ to transform the arbitrarily-ranged learnable scale parameters $\left\{ { { s } _ { t } } \right\}$ to positive scaling factors $\{ h \left( s _ { t } \right) > 0 \}$ , hereafter we abandon the subscript $t$ for brevity. Then we should construct an appropriate scaled loss $g \left( s \right)$ so that both network parameters $\pmb { \theta }$ and scale parameter $s$ can be optimized by minimizing $g \left( s \right)$ . On one hand, we balance different tasks by encouraging the scaled losses $h \left( s \right) L \left( \pmb { \theta } \right)$ to be 1 for all tasks, so the optimality $s ^ { \star }$ of $s$ is achieved when $h \left( s \right) L \left( \pmb { \theta } \right) = 1$ , or equivalently:
+
+$$
+f \left( s \right) \equiv h \left( s \right) L \left( \pmb { \theta } \right) - 1 = 0 , \mathrm { { i f } } s = s ^ { \star } .
+$$
+
+One may expect to minimize $\left| f \left( s \right) \right| = \left| h \left( s \right) L \left( \pmb { \theta } \right) - 1 \right|$ to find $s ^ { \star }$ , however when $h \left( s \right) L \left( \pmb { \theta } \right) < 1$ , the gradient with respect to $\pmb \theta$ , $\nabla _ { \pmb { \theta } } \left| f \left( s \right) \right| = - h \left( s \right) \nabla _ { \pmb { \theta } } L \left( \pmb { \theta } \right)$ , is in the opposite direction. On the other hand, assume our scaled loss $g \left( s \right)$ is a differentiable convex function with respect to $s$ , then its minimum is achieved if and only if $s = s ^ { \star }$ , where the derivative of $g \left( s \right)$ is zero:
+
+$$
+g ^ { \prime } \left( s \right) = 0 , { \mathrm { ~ i f ~ } } s = s ^ { \star } .
+$$
+
+From Eq. (3) and (4) we find that the values of $f \left( s \right)$ and $g ^ { \prime } \left( s \right)$ are both 0 when $s = s ^ { \star }$ , we can then regard $f \left( s \right)$ as the derivative of $g \left( s \right)$ , which is our target scaled loss and used to optimize both the network parameters $\pmb \theta$ and loss scale parameter $s$ , then we have:
+
+$$
+g ^ { \prime } \left( s \right) = f \left( s \right) \Leftrightarrow g \left( s \right) = \int f \left( s \right) \mathrm { d } s = L \left( \pmb { \theta } \right) \int h \left( s \right) \mathrm { d } s - s .
+$$
+
+From Eq. (3) and (5), we notice that both $h \left( s \right)$ and $\textstyle { \int h \left( s \right) \mathrm { d } s }$ denote loss scales, so we have $\begin{array} { r } { \int h \left( s \right) \mathrm { d } s = C h \left( s \right) } \end{array}$ , where $C > 0$ is a constant. According to ordinary differential equation, $\textstyle { \int h \left( s \right) \mathrm { d } s }$ must be the exponential function: $\textstyle \int h ( s ) \mathrm { d } s = b a ^ { s }$ with $a > 1 , b > 0$ (see Appendix B.2). We then have $g ^ { \prime \prime } ( { \bar { s } } ) = k a ^ { s }$ , $k > 0$ , which is always positive and verifies our assumption about the convexity of $g \left( s \right)$ . Also note that the gradient of $g \left( s \right)$ with respect to $\scriptstyle \partial , \nabla _ { \theta } g ( s ) =$ $\begin{array} { r } { \int h \left( s \right) \mathrm { d } s \nabla _ { \pmb { \theta } } L \left( \pmb { \theta } \right) = \dot { b a } ^ { s } \nabla _ { \pmb { \theta } } \dot { L } \left( \pmb { \theta } \right) } \end{array}$ , is in the appropriate direction since $b a ^ { s } > 0$ . As an instantiation, we set $\textstyle \int h ( s ) \mathrm { d } s = e ^ { s }$ $\mathbf { \Phi } _ { a } = e , b = 1$ ), then
+
+$$
+g \left( s \right) = e ^ { s } L \left( \pmb { \theta } \right) - s ,
+$$
+
+From Eq. (6) we find that the raw loss is scaled by $e ^ { s }$ , and $- s$ acts as a regularization to avoid the trivial solution $s = - \infty$ while minimizing the scaled loss $g \left( s \right)$ . As for implementation, the task losses $\{ L _ { t } \}$ are scaled by $\{ e ^ { s _ { t } } \}$ , and the scaled losses $\{ e ^ { s _ { t } } L - s _ { t } \}$ are used to update both the network parameters $\pmb \theta$ , $\{ \pmb \theta _ { t } \}$ and the scale parameters $\left\{ { { s } _ { t } } \right\}$ .
+
+# 3.3 HYBRID BALANCE: IMTL
+
+We have introduced IMTL-G/IMTL-L to achieve gradient/loss balance, and both of them produce scaling factors to be applied on the raw losses. They can be used solely, but we find them complementary and able to be combined to improve the performance. In IMTL-G, even if the raw losses are multiplied by arbitrary (maybe different among tasks) positive factors, the direction of the aggregated gradient $\textbf {  { g } }$ stays unchanged. Because by definition $\begin{array} { r } { \pmb { g } = \sum _ { t } \alpha _ { t } \pmb { g } _ { t } } \end{array}$ is the angular bisector of the gradients $\left\{ \pmb { g } _ { t } \right\}$ , and positive scaling will not change the directions of $\left\{ \pmb { g } _ { t } \right\}$ and thus that of $\textbf {  { g } }$ (proof in Theorem 2). So we can also obtain the scale factors $\left\{ \alpha _ { t } \right\}$ in IMTL-G with the losses that have been scaled by $\left\{ { { s } _ { t } } \right\}$ from IMTL-L. IMTL-G and IMTL-L are combined as: 1) the taskspecific parameters $\{ \pmb \theta _ { t } \}$ and scale parameters $\left\{ { { s } _ { t } } \right\}$ are updated by scaled losses $\{ e ^ { s _ { t } } L _ { t } - s _ { t } \} ; 2 )$ the task-shared parameters $\pmb { \theta }$ are updated by $\sum _ { t } \alpha _ { t } \left( e ^ { s _ { t } } L _ { t } \right)$ which is the weighted average of $\{ e ^ { s _ { t } } L _ { t } \}$ , with the weights $\left\{ \alpha _ { t } \right\}$ computed by $\{ \nabla _ { z } \left( e ^ { s _ { t } } L _ { t } \right) \}$ using IMTL-G. Note that the regularization terms $\left\{ - s _ { t } \right\}$ in Eq. (6) are constants with respect to $\pmb \theta$ and $_ { z }$ , and thus can be ignored when computing gradients and updating parameters in IMTL-G. In this way, we achieve both gradient balance for task-shared parameters and loss balance for task-specific parameters, leading to our full IMTL as illustrated in Alg. 1.
+
+# 4 DISCUSSION
+
+We draw connections between our method and previous state-of-the-arts 1 in Fig. 3. We will show that previous methods can all be categorized as gradient or loss balance, and thus each of them can be seen as a specification of our method. However, all of them have some intrinsic biases or short-comings leading to inferior performances, which we try to overcome.
+
+![](images/0cc456a558d91d5348db63c7ce2ae13f35779327ff115e981abb4de3646aaec9.jpg)  
+Figure 3: Relationship between our IMTL and previous methods. The blue dashed arrow indicates the characteristic of each method. In the loss balance methods, we annotate the scaled loss in the bracket. $L _ { \mathrm { c l s } }$ , $L _ { \mathrm { r e g } }$ and $L _ { t }$ are the raw loss of classification, regression and individual task, respectively. $\alpha _ { \mathrm { c l s } }$ , $\alpha _ { \mathrm { r e g } }$ and $\alpha _ { t }$ is the corresponding loss scale. $L$ is the geometric mean loss and $T$ is the task number. In the gradient balance methods, we annotate the projections of the aggregated gradient $\begin{array} { r } { \pmb { g } = \sum _ { t } \alpha _ { t } \pmb { g } _ { t } } \end{array}$ onto the raw gradient $\mathbf { \nabla } _ { \mathbf { \boldsymbol { g } } _ { t } }$ of the $t$ -th task in the bracket. $\pmb { u } _ { t } = \pmb { g } _ { t } / \left\| \hat { \pmb { g } _ { t } } \right\|$ is the unit-norm vector, $p _ { t } = g u _ { t } ^ { \top }$ is the projection of $\textbf {  { g } }$ onto $\mathbf { \nabla } _ { \mathbf { \boldsymbol { g } } _ { t } }$ and $\begin{array} { r } { \pmb { u } _ { s } = \sum _ { t } \pmb { u } _ { t } } \end{array}$ is the mean direction.
+
+GradNorm (Chen et al., 2018) balances tasks by making the norm of the scaled gradient for each task to be approximately equal. It also introduces the inverse training rate and a hyper-parameter $\gamma$ to control the strength of approaching the mean gradient norm, such that tasks which learn slower can receive larger gradient magnitudes. However, it does not take into account the relationship of the gradient directions. We show that when the angle between the gradients of each pair of tasks is identical, our IMTL-G leads to the equivalent solution as GradNorm.
+
+Theorem 1. If the angle between any pair of ${ \mathbf { } } { \mathbf { } } { \mathbf { } } u _ { t } , { \mathbf { } } u _ { \tau }$ stays constant: ${ \pmb u } _ { t } { \pmb u } _ { \tau } ^ { \top } = \underline { { C } } _ { 1 }$ , $\forall t \ne \tau$ with $C _ { 1 } < 1$ , then our IMTL- $G$ leads to the same solution as that of GradNorm: $g \mathbf { \boldsymbol { u } } _ { t } ^ { \intercal } = C _ { 2 } \Leftrightarrow n _ { t } \equiv$ $\lVert \alpha _ { t } \pmb { g } _ { t } \rVert = \alpha _ { t } \lVert \pmb { g } _ { t } \rVert = C _ { 3 }$ . In the above $\pmb { u } _ { t } = \pmb { g } _ { t } / \left\| \pmb { g } _ { t } \right\|$ , $C _ { 1 }$ , $C _ { 2 }$ and $C _ { 3 }$ are constants.
+
+Proof in Appendix C.1. In GradNorm, if without the above constant-angle condition ${ \pmb u } _ { t } { \pmb u } _ { \tau } ^ { \top } = C _ { 1 }$ , the projection of the aggregated gradient $\textbf {  { g } }$ onto task-specific gradient, $\begin{array} { r } { \bar { \mathbf { g } } \mathbf { \pmb { u } } _ { t } ^ { \top } = ( \sum _ { \tau } C _ { 3 } \dot { \pmb { u } _ { \tau } } ) \mathbf { \delta } \mathbf { u } _ { t } ^ { \top } = } \end{array}$ $\begin{array} { r } { C _ { 3 } \left( \sum _ { \tau } \pmb { u } _ { \tau } \right) \pmb { u } _ { t } ^ { \top } } \end{array}$ , is proportional to $\begin{array} { r } { ( \sum _ { \tau } { \pmb u } _ { \tau } ) { \pmb u } _ { t } ^ { \top } } \end{array}$ . It tends to optimize the “majority tasks” whose gradient directions are closer to the mean direction $\sum _ { t } \mathbf { \nabla } \mathbf { u } _ { t }$ , resulting in undesired task bias.
+
+MGDA (Sener & Koltun, 2018) finds the weighted average gradient $\begin{array} { r } { \pmb { g } = \sum _ { t } \alpha _ { t } \pmb { g } _ { t } } \end{array}$ with minimum norm in the convex hull composed by $\left\{ \pmb { g } _ { t } \right\}$ , so that $\textstyle \sum _ { t } \alpha _ { t } { \bar { = } } { \bar { 1 } }$ and $\alpha _ { t } \geqslant 0$ , $\forall t$ . It adopts an iterative method based on Frank-Wolfe algorithm to solve the multi-objective optimization problem. We note the minimum-norm point has a closed-form representation if without the constraints $\{ \alpha _ { t } \geqslant 0 \}$ . In this case, we try to minimize $\begin{array} { r } { \pmb { g } \pmb { g } ^ { \top } = \left( \sum _ { t } \alpha _ { t } \pmb { g } _ { t } \right) \left( \sum _ { \tau } \alpha _ { \tau } \pmb { g } _ { \tau } \right) ^ { \top } } \end{array}$ such that $\textstyle \sum _ { t } \alpha _ { t } = 1$ . It implies $\textbf {  { g } }$ is perpendicular to the hyper-plane composed by $\left\{ \pmb { g } _ { t } \right\}$ as illustrated in Fig 1 (b), and thus we have:
+
+$$
+g \perp \left( g _ { 1 } - g _ { t } \right) \Leftrightarrow g \left( g _ { 1 } - g _ { t } \right) ^ { \top } = 0 , \forall 2 \leqslant t \leqslant T ,
+$$
+
+and can obtain $\alpha = g _ { 1 } D ^ { \top } \left( D D ^ { \top } \right) ^ { - 1 }$ (see Appendix C.2). From Eq. (7), we note that the aggregated gradient satisfies: $g g _ { t } ^ { \top } = C$ . Then the projection of $\textbf {  { g } }$ onto $\mathbf { \sigma } _ { \mathbf { \sigma } _ { \mathbf { \sigma } _ { \mathbf { \lambda } } } } \mathbf { \sigma } _ { \mathbf { \sigma } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \mathbf { \lambda } } } \mathbf { \sigma } _ { \mathbf { \lambda } _ { \mathbf { \lambda } } }$ , $\pmb { g u } _ { t } ^ { \top } = C / \left\| \pmb { g } _ { t } \right\|$ , is inversely proportional to the norm of $\mathbf { \nabla } _ { \mathbf { \boldsymbol { g } } _ { t } }$ . So it focuses on tasks with smaller gradient magnitudes, which breaks the task balance. Even with $\{ \alpha _ { t } \geqslant 0 \}$ , the problem still exists (see Appendix C.2) in the original MGDA method. Through experiments, we note that finding the minimum-norm point without the constraints $\{ \alpha _ { t } \geqslant 0 \}$ leads to similar performance as MGDA with the constraints $\{ \alpha _ { t } \geqslant 0 \}$ . In our IMTL-G, although we do not constrain $\left\{ \alpha _ { t } \geqslant 0 \right\}$ , its loss weighting scales are always positive during the training procedure as shown in Fig. 4.
+
+Uncertainty weighting (Kendall et al., 2018) regards the task uncertainty as loss weight. For regression, it can derive $L _ { 1 }$ loss from Laplace distribution: $- \log p \left( y \mid f \left( x \right) \right) = \left| y - f \left( x \right) \right| / b + \log b$ , where $_ { \textbf { \em x } }$ is the data sample, $y$ is the ground-truth label, $f$ denotes the prediction model and $b$ is the diversity of Laplace distribution. $L _ { 2 }$ loss can be found in Appendix C.4. For classification, it takes the cross-entropy loss as a scaled categorical distribution and introduces the following approximation:
+
+$$
+- \log p \left( \boldsymbol { y } \mid \boldsymbol { f } \left( \boldsymbol { x } \right) \right) = - \log \left[ \mathrm { s o f t m a x } _ { \boldsymbol { y } } \left( \frac { \boldsymbol { f } \left( \boldsymbol { x } \right) } { \sigma ^ { 2 } } \right) \right] \approx - \frac { 1 } { \sigma ^ { 2 } } \log \left[ \mathrm { s o f t m a x } _ { \boldsymbol { y } } \left( \boldsymbol { f } \left( \boldsymbol { x } \right) \right) \right] + \log \sigma ,
+$$
+
+in which $\operatorname { s o f t m a x } _ { y }$ (·) stands for taking the $y$ -th entry after the softmax $( \cdot )$ operator. MTL corresponds to maximizing the joint likelihood of multiple targets, then the derivations yield the scaling factor $b / \sigma$ for the regression/classification loss. (Kendall et al., 2018) learn $b$ and $\sigma$ as model parameters which are updated by stochastic gradient descent. However, it is applicable only if we can find appropriate correspondence between the loss and the distribution. It is difficult to be used for losses such as cosine similarity, and it is impossible to traverse all kinds of losses to obtain a unified form for them. Moreover, it sacrifices classification tasks. From Eq. (8) we can find that the scaled cross-entropy loss is approximated as $L = e ^ { 2 s } L _ { \mathrm { c l s } } - s$ if we set $s = - \log \sigma$ . By taking the derivative we have $\partial \bar { L } / \partial s = \bar { 2 e } ^ { \bar { 2 } s } L _ { \mathrm { c l s } } - 1$ . Then $s$ is optimized to make the scaled loss $e ^ { 2 s } \bar { L } _ { \mathrm { c l s } }$ to be close to $1 / 2$ . However, the scaled $L _ { 1 }$ loss is approximated as $L = e ^ { s } L _ { \mathrm { r e g } } - s$ if we set $s = - \log b$ , and taking the derivative we have $\partial L / \partial s = e ^ { s } L _ { \mathrm { r e g } } - 1$ . So $s$ is optimized to make the scaled $L _ { 1 }$ loss to achieve 1, which is twice of the classification loss, and thus the classification task is overlooked.
+
+We would like to remark the differences between our IMTL-L and uncertainty weighting (Kendall et al., 2018). Firstly, our derivation is motivated by the fairness among tasks, which intrinsically differs from uncertainty weighting which is based on task uncertainty considering each task independently. Secondly, IMTL-L learns to balance among tasks without any biases, while uncertainty weighting may sacrifice classification tasks to favor regression tasks as derived above. Thirdly, IMTL-L does not depend on any distribution assumptions and thus can be generally applied to various losses including cosine similarity, which uncertainty weighting may have difficulty with. As far as we know, there is no appropriate correspondence between cosine similarity and specific distributions. Lastly, uncertainty weighting needs to deal with different losses case by case, it also introduces approximations in order to derive scaling factors for certain losses (such as cross-entropy loss) which may not be optimal, but our IMTL-L has a unified form for all kinds of losses.
+
+GLS (Chennupati et al., 2019) calculates the target loss as the geometric mean: $L = ( \prod _ { t } L _ { t } ) ^ { \frac { 1 } { T } }$ , then the gradient of $L$ with respect to the model parameters $\pmb { \theta }$ can be obtained as Appendix C.5, which can be regarded as to weigh the loss with its reciprocal value. However, as the gradient depends on the value of $L$ , so it is not scale-invariant to the loss scale changes. Moreover, we find it to be unstable when the number of tasks is large because of the geometric mean computation.
+
+# 5 EXPERIMENTS
+
+In previous methods, various experimental settings have been adopted but there are no extensive comparisons. As one contribution of our work, we re-implement representative methods and present fair comparisons among them under the unified code-base, where more practical settings are adopted and stronger performances are achieved compared with existing code-bases. The implementations exactly follow the original papers and open-sourced code to ensure the correctness. We run experiments on the Cityscapes (Cordts et al., 2016), NYUv2 (Silberman et al., 2012) and CelebA (Liu et al., 2015) dataset to extensively analyze different methods. Details can be found in Appendix D.
+
+Results on Cityscapes. From Tab. 1 we can obtain several informative conclusions. The uniform scaling baseline, which na¨ıvely adds all losses, tends to optimize tasks with larger losses and gradient magnitudes, resulting in severe task bias. Uncertainty weighting (Kendall et al., 2018) sacrifices classification tasks to aid regression ones, leading to significantly worse results on semantic segmentation compared with our IMTL-L. GradNorm (Chen et al., 2018) is very sensitive to the choice of the hyper-parameter $\gamma$ controlling the strength of equal gradient magnitudes, where the default $\gamma = 1 . 5$ works well on NYUv2 but performs badly on Cityscapes. We find its best option is $\gamma = 0$ which makes the scaled gradient norm to be exactly equal. MGDA (Sener & Koltun, 2018) focuses on tasks with smaller gradient magnitudes. So the performance of semantic segmentation is good but the other two tasks have difficulty in converging. In addition, we find our proposed closed-form variant without the hard constraints $\{ \alpha _ { t } \geqslant 0 \}$ achieves similar results as the original iterative method. Through the experiments we notice the closed-form solution almost always yields $\{ \alpha _ { t } \geqslant 0 \}$ . As for PCGrad (Yu et al., 2020), it yields slightly better performance than uniform scaling because its conflict projection will have no effect when the angles between the gradients are equal or less than $\pi / 2$ . In contrast, our IMTL method, in terms of both gradient balance and loss balance, yields competitive performance and achieves the best balance among tasks. Moreover, we verify that the two balances are complementary and can be combined to further improve the performance, with the visualizations in Appendix E. Surprisingly, we find our IMTL can beat the single-task baseline where
+
+Table 1: Comparison between IMTL and previous methods on Cityscapes, semantic segmentation, instance segmentation and disparity/depth estimation are considered. The first group of columns shows the regular results of different methods. The second group shows the results by manually multiply the semantic segmentation loss with 10 before applying these methods. The subscript numbers show the absolute change after scaling the loss to demonstrate the robustness of various methods. The arrows indicate the values are the higher the better (↑) or the lower the better (↓). The best and runner up results for each task are bold and underlined, respectively.
+
+<table><tr><td>method</td><td>sem. mIoU↑</td><td>ins. L1↓</td><td>disp. L1↓</td><td>sem. mIoU↑△↓</td><td>ins. L1↓△</td><td>disp. L1↓△</td><td>time s/iter↓</td></tr><tr><td>baselines</td><td>76.67</td><td>21.61</td><td>4.182</td><td></td><td></td><td></td><td>=</td></tr><tr><td>single-task uniform scaling</td><td>58.99</td><td>18.13</td><td>3.512</td><td></td><td></td><td></td><td>1.201</td></tr><tr><td>loss balance uncertainty (Kendall et al., 2018)</td><td>74.91</td><td>16.43</td><td>2.895</td><td>74.000.91</td><td>16.770.34</td><td>2.9300.035</td><td>1.204</td></tr><tr><td>GLS (Chennupati et al., 2019) IMTL-L</td><td>75.65 76.89</td><td>17.18</td><td>2.953</td><td>66.229.43</td><td>21.093.91</td><td>3.3580.405</td><td>1.202 1.202</td></tr><tr><td>gradient balance</td><td></td><td>16.69</td><td>2.944</td><td>75.551.34</td><td>17.490.80</td><td>2.9720.028</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>GradNorm ( = 0)</td><td>76.27</td><td>17.99</td><td>3.195</td><td>72.963.31</td><td>19.361.37</td><td>3.2160.021</td><td>1.741</td></tr><tr><td>GradNorm (Chen et al., 2018)</td><td>52.17</td><td>19.88</td><td>4.098</td><td>54.232.06</td><td>20.530.65</td><td>4.1080.010</td><td>1.742</td></tr><tr><td>MGDA(w/o {αt ≥ 0})</td><td>76.95</td><td>53.19</td><td>6.296</td><td>76.360.59</td><td>29.0624.13</td><td>3.3772.919</td><td>1.777</td></tr><tr><td>MGDA (Sener &amp; Koltun,2018)</td><td>76.56</td><td>53.14</td><td>6.644</td><td>72.354.21</td><td>29.3823.76</td><td>3.3363.308</td><td>1.732</td></tr><tr><td>PCGrad (Yu et al., 2020)</td><td>60.50</td><td>17.99</td><td>3.450</td><td>66.335.83</td><td>17.990.00</td><td></td><td>2.087</td></tr><tr><td></td><td>76.13</td><td>17.46</td><td>2.979</td><td></td><td></td><td>3.3860.064</td><td></td></tr><tr><td>IMTL-G (exact)</td><td>76.52</td><td>16.61</td><td>2.997</td><td>-</td><td></td><td>=</td><td>2.769</td></tr><tr><td>IMTL-G</td><td></td><td></td><td></td><td>76.060.46</td><td>17.520.91</td><td>3.0200.023</td><td>1.776</td></tr><tr><td>hybrid balance IMTL</td><td>77.00</td><td>15.96</td><td>2.905</td><td>76.560.44</td><td>15.850.11</td><td>2.9380.033</td><td>1.795</td></tr></table>
+
+each task is trained with a separate model. Training multiple tasks simultaneously can learn a better representation from multiple levels of semantics, which can in turn improve individual tasks.
+
+In addition, we present the real-world training time of each iteration for different methods in Tab. 1. As shown, loss balance methods are the most efficient, and our gradient balance method IMTLG adds acceptable computational overhead, similar to that of GradNorm (Chen et al., 2018) and MGDA (Sener & Koltun, 2018). It benefits from computing gradients with respect to the shared feature maps instead of the shared model parameters (the row of “IMTL-G (exact)”), which brings similar performances but adds significant complexity due to multiple $( T )$ backward passes through the shared parameters. Our IMTL-G only needs to do backward computation on the shared parameters once after obtaining the loss weights via Eq. (2), in which the computation overhead mainly comes from the matrix multiplication rather than the matrix inverse, since the inversed matrix $\bar { D } U ^ { \top } \in \mathbb { R } ^ { ( T - 1 ) \times ( T - 1 ) }$ is small compared with dimension of the shared feature $_ z$ .
+
+As we outperform MGDA (Sener & Koltun, 2018) and PCGrad (Yu et al., 2020) significantly in terms of the objective metrics shown in Tab. 1, we further compare the qualitative results of our hybrid balance IMTL with the loss balance method uncertainty weighting (Kendall et al., 2018) and the gradient balance method GradNorm (Chen et al., 2018) considering their strong performances (see Fig. 6). For depth estimation we only show predictions at the pixels where ground truth (GT) labels exist to compare with GT, which is different from Fig. 7 where depth predictions are shown for all pixels. Consistent with results in Tab. 1, our IMTL shows visually noticeable improvements especially for the semantic and instance segmentation tasks. It is worth noting that we conduct experiments under strong baselines and practical settings which are seldom explored before, in this case changing the backbone in PSPNet (Zhao et al., 2017) from ResNet-50 to ResNet-101 can only improve mIoU of the semantic segmentation task around $0 . 5 \%$ according to the public code base2.
+
+Scale invariance. We are also interested in the scale invariance, which means how the results change with the loss scale. For example, in semantic segmentation, the loss scale is different if we replace the reduction method “mean” (averaged over all locations) with “sum” (summed over all locations) in the cross-entropy loss computation, or the number of the interested classes increases. The scale invariance is beneficial for model robustness. So to simulate this effect, we manually multiply the semantic segmentation loss by 10 and apply the same methods to see how the performances are affected. In the last three columns of Tab. 1 we report the absolute changes resulting from the multiplier. Our IMTL achieves the smallest performance fluctuations and thus the best invariance, while other methods are more or less affected by the loss scale change.
+
+Table 2: Experimental results on the NYUv2 and CelebA datasets, semantic segmentation, surface normal estimation, depth estimation and multi-class classification are considered. Arrows indicate the values are the higher the better (↑) or the lower the better (↓). The best and runner up results in each column are bold and underlined, respectively.   
+
+<table><tr><td>method</td><td>sem. mIoU↑</td><td>NYUv2 norm. cos↑</td><td>depth L↓</td><td>CelebA class. acc.↑</td></tr><tr><td>baselines single-task uniform scaling lossbalance</td><td>56.82 57.40</td><td>0.8827 0.8684</td><td>0.5097 0.4248</td><td>= 90.01</td></tr><tr><td>uncertainty (Kendall et al., 2018) GLS (Chennupati et al., 2019) IMTL-L gradientbalance GradNorm ( = 0)</td><td>57.20 57.84 58.36 55.96</td><td>0.8762 0.8864</td><td>0.4400 0.4243 0.4173</td><td>90.34 = 90.54</td></tr><tr><td>GradNorm (Chen et al., 2018) MGDA (w/o {αt ≥ 0}) MGDA (Sener &amp; Koltun, 2018) PCGrad (Yu et al., 2020) IMTL-G</td><td>56.92 49.43 49.44 57.48 57.00</td><td>0.8818 0.8787 0.8877 0.8875 0.8696 0.8785</td><td>0.4317 0.4285 0.4839 0.4759 0.4253 0.4226</td><td>90.91 89.92 89.68 90.04 89.99 91.03</td></tr><tr><td>hybridbalance IMTL</td><td>58.85</td><td>0.8888</td><td>0.4215</td><td>91.12</td></tr></table>
+
+Results on NYUv2. In Tab. 2 we find similar patterns as on Cityscapes, but NYUv2 is a rather small dataset, so uniform scaling can also obtain reasonable results. Note that uncertainty weighting (Kendall et al., 2018) cannot be directly used to estimate the normal surface when the cosine similarity is used as the loss, since no appropriate distribution can be found to correspond to cosine similarity. In this case, surface normal estimation owns the smallest gradient magnitude, so MGDA (Sener & Koltun, 2018) learns it best but it performs not so well for the rest two tasks. Again, our IMTL performs best taking advantage of the complementary gradient and loss balances.
+
+Results on CelebA. To compare different methods in the many-task setting, in Tab. 2 we also conduct the multi-label classification experiments on the CelebA (Liu et al., 2015) dataset. The mean accuracy of 40 tasks is used as the final metric. Our IMTL outperforms its competitors in the scenario where the task number is large, showing its superiority. Note that in this setting, GLS (Chennupati et al., 2019) has difficulty in converging and no reasonable results can be obtained.
+
+# 6 CONCLUSION
+
+We propose an impartial multi-task learning method integrating gradient balance and loss balance, which are applied on task-shared and task-specific parameters, respectively. Through our in-depth analysis, we have theoretically compared our method with previous state-of-the-arts. We have also showed that those state-of-the-arts can all be categorized as gradient or loss balance, but lead to specific bias among tasks. Through extensive experiments we verify our analysis and demonstrate the effectiveness of our method. Besides, for fair comparisons, we contribute a unified code-base, which adopts more practical settings and delivers stronger performances compared with existing code-bases, and it will be publicly available for future research.
+
+# ACKNOWLEDGEMENTS
+
+This work was supported by the Natural Science Foundation of Guangdong Province (No. 2020A1515010711), the Special Foundation for the Development of Strategic Emerging Industries of Shenzhen (No. JCYJ20200109143010272), and the Innovation and Technology Commission of the Hong Kong Special Administrative Region, China (Enterprise Support Scheme under the Innovation and Technology Fund B/E030/18).
+
+# REFERENCES
+
+Rich Caruana. Multitask learning. Machine learning, 28(1):41–75, 1997.
+
+Liang-Chieh Chen, George Papandreou, Iasonas Kokkinos, Kevin Murphy, and Alan L Yuille. Deeplab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected crfs. IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(4): 834–848, 2017.
+
+Zhao Chen, Vijay Badrinarayanan, Chen-Yu Lee, and Andrew Rabinovich. Gradnorm: Gradient normalization for adaptive loss balancing in deep multitask networks. In International Conference on Machine Learning, pp. 794–803, 2018.
+
+Sumanth Chennupati, Ganesh Sistu, Senthil Yogamani, and Samir A Rawashdeh. Multinet++: Multi-stream feature aggregation and geometric loss strategy for multi-task learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, 2019.
+
+Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3213–3223, 2016.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In 2009 IEEE Conference on Computer Vision and Pattern Recognition, pp. 248–255. IEEE, 2009.
+
+Theodoros Evgeniou and Massimiliano Pontil. Regularized multi–task learning. In Proceedings of the tenth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 109–117, 2004.
+
+Yuan Gao, Jiayi Ma, Mingbo Zhao, Wei Liu, and Alan L Yuille. Nddr-cnn: Layerwise feature fusing in multi-task cnns by neural discriminative dimensionality reduction. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3205–3214, 2019.
+
+Yuan Gao, Haoping Bai, Zequn Jie, Jiayi Ma, Kui Jia, and Wei Liu. Mtl-nas: Task-agnostic neural architecture search towards general-purpose multi-task learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 11543–11552, 2020.
+
+Michelle Guo, Albert Haque, De-An Huang, Serena Yeung, and Li Fei-Fei. Dynamic task prioritization for multitask learning. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 270–287, 2018.
+
+Pengsheng Guo, Chen-Yu Lee, and Daniel Ulbricht. Learning to branch for multi-task learning. In International Conference on Machine Learning, 2020.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 770–778, 2016.
+
+Jie Hu, Li Shen, and Gang Sun. Squeeze-and-excitation networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7132–7141, 2018.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning - Volume 37, pp. 448–456, 2015.
+
+Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7482–7491, 2018.
+
+Shikun Liu, Edward Johns, and Andrew J Davison. End-to-end multi-task learning with attention. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1871– 1880, 2019.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3730–3738, 2015.
+
+Jiasen Lu, Vedanuj Goswami, Marcus Rohrbach, Devi Parikh, and Stefan Lee. 12-in-1: Multi-task vision and language representation learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10437–10446, 2020.
+
+Arun Mallya, Dillon Davis, and Svetlana Lazebnik. Piggyback: Adapting a single network to multiple tasks by learning to mask weights. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 67–82, 2018.
+
+Kevis-Kokitsi Maninis, Ilija Radosavovic, and Iasonas Kokkinos. Attentive single-tasking of multiple tasks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1851–1860, 2019.
+
+Ishan Misra, Abhinav Shrivastava, Abhinav Gupta, and Martial Hebert. Cross-stitch networks for multi-task learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3994–4003, 2016.
+
+Chao Peng, Tete Xiao, Zeming Li, Yuning Jiang, Xiangyu Zhang, Kai Jia, Gang Yu, and Jian Sun. Megdet: A large mini-batch object detector. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6181–6189, 2018.
+
+Sylvestre-Alvise Rebuffi, Hakan Bilen, and Andrea Vedaldi. Learning multiple visual domains with residual adapters. In Advances in Neural Information Processing Systems, pp. 506–516, 2017.
+
+Sebastian Ruder. An overview of multi-task learning in deep neural networks. arXiv preprint arXiv:1706.05098, 2017.
+
+Sebastian Ruder, Joachim Bingel, Isabelle Augenstein, and Anders Søgaard. Latent multi-task architecture learning. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 4822–4829, 2019.
+
+Ozan Sener and Vladlen Koltun. Multi-task learning as multi-objective optimization. In Advances in Neural Information Processing Systems, pp. 527–538, 2018.
+
+Nathan Silberman, Derek Hoiem, Pushmeet Kohli, and Rob Fergus. Indoor segmentation and support inference from rgbd images. In European Conference on Computer Vision, pp. 746–760. Springer, 2012.
+
+Trevor Standley, Amir R Zamir, Dawn Chen, Leonidas Guibas, Jitendra Malik, and Silvio Savarese. Which tasks should be learned together in multi-task learning? In International Conference on Machine Learning, 2020.
+
+Gjorgji Strezoski, Nanne van Noord, and Marcel Worring. Many task learning with task routing. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1375–1384, 2019.
+
+Tianhe Yu, Saurabh Kumar, Abhishek Gupta, Sergey Levine, Karol Hausman, and Chelsea Finn. Gradient surgery for multi-task learning. arXiv preprint arXiv:2001.06782, 2020.
+
+Amir R Zamir, Alexander Sax, William Shen, Leonidas J Guibas, Jitendra Malik, and Silvio Savarese. Taskonomy: Disentangling task transfer learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3712–3722, 2018.
+
+Amir R Zamir, Alexander Sax, Nikhil Cheerla, Rohan Suri, Zhangjie Cao, Jitendra Malik, and Leonidas J Guibas. Robust learning through cross-task consistency. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 11197–11206, 2020.
+
+Yu Zhang and Qiang Yang. A survey on multi-task learning. arXiv preprint arXiv:1707.08114, 2017.
+
+Hengshuang Zhao, Jianping Shi, Xiaojuan Qi, Xiaogang Wang, and Jiaya Jia. Pyramid scene parsing network. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2881–2890, 2017.
+
+Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In Proceedings of the International Conference on Learning Representations, 2017.
+
+# A RELATED WORK OF NETWORK STRUCTURE
+
+Cross-stitch Networks (Misra et al., 2016) learn coefficients to linearly combine activations from multiple tasks to construct better task-specific representations. To break the limitation of channelwise cross-task feature fusion only, NDDR-CNN (Gao et al., 2019) proposes the layer-wise crosschannel feature aggregation as $1 \times 1$ convolutions on the concatenated feature maps from multiple tasks. More generally, MTL-NAS (Gao et al., 2020) introduces cross-layer connections among tasks to fully exploit the feature sharing from both low and high layers, extending the idea in Sluice Networks (Ruder et al., 2019) by leveraging neural architecture search (Zoph & Le, 2017). The parameters of these methods increase linearly with the number of tasks. To improve the model compactness, Residual Adapters (Rebuffi et al., 2017) introduce a small amount of task-specific parameters for each layer and convolve them with the task-agnostic representations to form the taskrelated ones. MTAN (Liu et al., 2019) generates data-dependent attention tensors by task-specific parameters to attend to the task-shared features. Single-tasking (Maninis et al., 2019) instead applies squeeze-and-excitation (Hu et al., 2018) module to generate attentive vectors for each task. In Task Routing (Strezoski et al., 2019), the attentive vectors are randomly sampled before training and are fixed for each image. Piggyback (Mallya et al., 2018) opts to mask parameter weights in place of activation maps, dealing with task-sharing from another point-of-view. The above methods can share parameters among tasks to a large extent, however, they are not memory-efficient because each task still needs to compute all of its own intermediate feature maps, which also leads to inferior inference speed compared with loss weighting methods.
+
+# B DETAILED DERIVATION
+
+# B.1 GRADIENT BALANCE: IMTL-G
+
+Here we give the detailed derivation of the closed-form solution of our IMTL-G, we also demonstrate the scale-invariance property of our IMTL-G, which is invariant to the scale changes of losses.
+
+Solution. As we want to achieve:
+
+$$
+g \pmb { u } _ { 1 } ^ { \top } = \pmb { g } \pmb { u } _ { t } ^ { \top } \Leftrightarrow \pmb { g } \left( \pmb { u } _ { 1 } - \pmb { u } _ { t } \right) ^ { \top } = 0 , \forall 2 \leqslant t \leqslant T ,
+$$
+
+where $\pmb { u } _ { t } = \pmb { g } _ { t } / \left\| \pmb { g } _ { t } \right\|$ , recall that we have $\begin{array} { r } { \pmb { g } = \sum _ { t } \alpha _ { t } \pmb { g } _ { t } } \end{array}$ and $\textstyle \sum _ { t } \alpha _ { t } = 1$ , if we set ${ \pmb { \alpha } } = [ \alpha _ { 2 } , \cdots , \alpha _ { T } ]$ and $G ^ { \top } = \left[ \pmb { g } _ { 2 } ^ { \top } , \cdots , \pmb { g } _ { T } ^ { \top } \right]$ , then $\alpha _ { 1 } = 1 - 1 \alpha ^ { \top }$ and Eq. (9) can be expanded as:
+
+$$
+\left( \sum _ { t } \alpha _ { t } g _ { t } \right) \left[ u _ { 1 } ^ { \top } - u _ { 2 } ^ { \top } , \cdots , u _ { 1 } ^ { \top } - u _ { T } ^ { \top } \right] = \mathbf { 0 } \Leftrightarrow \left[ \begin{array} { l l } { 1 - \mathbf { 1 } \alpha ^ { \top } , } & { \alpha } \end{array} \right] \left[ \begin{array} { l } { g _ { 1 } } \\ { G } \end{array} \right] U ^ { \top } = \mathbf { 0 } ,
+$$
+
+where $\pmb { U } ^ { \top } = \left[ \pmb { u } _ { 1 } ^ { \top } - \pmb { u } _ { 2 } ^ { \top } , \cdot \cdot \cdot , \pmb { u } _ { 1 } ^ { \top } - \pmb { u } _ { T } ^ { \top } \right]$ , 1 and 0 indicate the all-one and all-zero row vector, respectively. Eq. (10) can be solved by:
+
+$$
+\left[ \left( 1 - \mathbf { 1 } \alpha ^ { \top } \right) \boldsymbol { g } _ { 1 } + \alpha \boldsymbol { G } \right] \boldsymbol { U } ^ { \top } = \mathbf { 0 } \Leftrightarrow \alpha \left( \mathbf { 1 } ^ { \top } \boldsymbol { g } _ { 1 } - \boldsymbol { G } \right) \boldsymbol { U } ^ { \top } = \boldsymbol { g } _ { 1 } \boldsymbol { U } ^ { \top } .
+$$
+
+Assume $\pmb { { \cal D } } ^ { \top } = \pmb { \mathfrak { g } } _ { 1 } ^ { \top } \pmb { 1 } - \pmb { { \cal G } } ^ { \top } = \left[ \pmb { \mathfrak { g } } _ { 1 } ^ { \top } - \pmb { \mathfrak { g } } _ { 2 } ^ { \top } , \cdots , \pmb { \mathfrak { g } } _ { 1 } ^ { \top } - \pmb { \mathfrak { g } } _ { T } ^ { \top } \right]$ , then we reach:
+
+$$
+\begin{array} { r } { \alpha D U ^ { \top } = g _ { 1 } U ^ { \top } \Leftrightarrow \alpha = g _ { 1 } U ^ { \top } \left( D U ^ { \top } \right) ^ { - 1 } . } \end{array}
+$$
+
+Property. We can also prove the aggregated gradient $\begin{array} { r } { \pmb { g } = \sum _ { t } \alpha _ { t } \pmb { g } _ { t } } \end{array}$ with $\{ \alpha _ { t } \}$ given in Eq. (12) is invariant to the scale changes of losses $\{ L _ { t } \}$ (or gradients $\{ \overline { { g _ { t } } } = \nabla _ { \pmb { \theta } } L _ { t } \}$ ), as the following theorem.
+
+Theorem 2. Given $\begin{array} { r } { \mathbf { \nabla } \mathbf { g } = \sum _ { t } \alpha _ { t } \mathbf { \nabla } \mathbf { g } _ { t } } \end{array}$ , $\textstyle \sum _ { t } \alpha _ { t } \ = \ 1$ satisfying $g u _ { t } ^ { \top } = C$ , when $\{ L _ { t } \}$ are scaled by $\{ k _ { t } > 0 \}$ (equivalently, $\left\{ \pmb { g } _ { t } \right\}$ are scaled by $\{ k _ { t } \} ,$ ), $\begin{array} { r } { i f g ^ { \prime } = \sum _ { t } \alpha _ { t } ^ { \prime } \left( k _ { t } g _ { t } \right) , \sum _ { t } \alpha _ { t } ^ { \prime } = 1 } \end{array}$ satisfies $\mathbf { \nabla } \mathbf { g } ^ { \prime } \mathbf { \bar { u } } _ { t } ^ { \top } =$ C0, then g0 = λg. In the above we have ut = gtkgtk $\begin{array} { r } { \pmb { u } _ { t } = \frac { \pmb { g } _ { t } } { \lVert \pmb { g } _ { t } \rVert } = \frac { k _ { t } \pmb { g } _ { t } } { \lVert k _ { t } \pmb { g } _ { t } \rVert } } \end{array}$ = ktgtkktgtk , λ, C and C 0 are constants.
+
+![](images/c2956dd2f205868fc6f212a06e8fa0b69bcf2979e0115796a660737bc78a90ef.jpg)  
+Figure 4: Loss scales of IMTL-G for different tasks when training on the Cityscapes dataset.
+
+Proof. As we have:
+
+$$
+\pmb { g } = \sum _ { t } \alpha _ { t } \pmb { g } _ { t } = \sum _ { t } \frac { \alpha _ { t } } { k _ { t } } k _ { t } \pmb { g } _ { t } \quad \mathrm { a n d } \quad g \pmb { u } _ { t } ^ { \top } = C ,
+$$
+
+by constructing:
+
+$$
+\alpha _ { t } ^ { \prime } = \frac { \alpha _ { t } } { k _ { t } } / \sum _ { \tau } \frac { \alpha _ { \tau } } { k _ { \tau } } { \quad \mathrm { a n d } \quad } g ^ { \prime } = \sum _ { t } \alpha _ { t } ^ { \prime } \left( k _ { t } g _ { t } \right) = g / \sum _ { \tau } \frac { \alpha _ { \tau } } { k _ { \tau } } = \lambda g ,
+$$
+
+we have:
+
+$$
+\sum _ { t } \alpha _ { t } ^ { \prime } = 1 \quad \mathrm { a n d } \quad g ^ { \prime } \pmb { u } _ { t } ^ { \top } = C / \sum _ { \tau } \frac { \alpha _ { \tau } } { k _ { \tau } } = C ^ { \prime } .
+$$
+
+From Eq. (12) we know that $\left\{ \alpha _ { t } \right\}$ has a unique solution, and thus $\pmb { g } ^ { \prime }$ satisfying IMTL-G is unique, so it must be the one given by Eq. (14), then we can prove that $g ^ { \prime }$ and $\textbf {  { g } }$ are linearly correlated.
+
+# B.2 LOSS BALANCE: IMTL-L
+
+With the ordinary differential equation, we can derive that the form of the scale function $\textstyle { \int h \left( s \right) \mathrm { d } s }$ in our IMTL-L must be exponential function. As we have:
+
+$$
+\int h \left( s \right) \mathrm { d } s = C h \left( s \right) , C > 0 .
+$$
+
+If we set $\begin{array} { r } { y = \int h \left( s \right) \mathrm { d } s } \end{array}$ , then:
+
+$$
+y = C \frac { \mathrm { d } y } { \mathrm { d } s } \Rightarrow \frac { \mathrm { d } y } { y } = \frac { 1 } { C } \mathrm { d } s ,
+$$
+
+By taking the antiderivative:
+
+$$
+\int \frac { \mathrm { d } y } { y } = \frac { 1 } { C } \int \mathrm { d } s \Rightarrow \ln y = \frac { 1 } { C } s + C ^ { \prime } .
+$$
+
+Then we have:
+
+$$
+\int h \left( s \right) \mathrm { d } s = y = e ^ { C ^ { \prime } } \left( e ^ { \frac { 1 } { C } } \right) ^ { s } = b a ^ { s } , ~ a > 1 , ~ b > 0 .
+$$
+
+# C DETAILED DISCUSSION
+
+C.1 CONDITIONAL EQUIVALENCE OF IMTL-G AND GRADNORM
+
+First we introduce the following lemma.
+
+Lemma 3. If ${ \pmb u } _ { t } { \pmb u } _ { \tau } ^ { \top } = C _ { 1 }$ , $\forall t \neq \tau$ , then the solution $\{ \alpha _ { t } \}$ of IMTL-G satisfies $\{ \alpha _ { t } > 0 \}$ .
+
+Proof. As $\pmb { u } _ { t } = \pmb { g } _ { t } / \left\| \pmb { g } _ { t } \right\|$ , by constructing $\begin{array} { r } { \pmb { g } = \sum _ { t } \alpha _ { t } \pmb { g } _ { t } } \end{array}$ where:
+
+$$
+\alpha _ { t } = \left\| \pmb { g } _ { t } \right\| ^ { - 1 } / \sum _ { \tau } \left\| \pmb { g } _ { \tau } \right\| ^ { - 1 } ,
+$$
+
+then we have $\textstyle \sum _ { t } \alpha _ { t } = 1$ and:
+
+$$
+g \pmb { u } _ { t } ^ { \top } = \left( \sum _ { \tau } \pmb { u } _ { \tau } \pmb { u } _ { t } \right) / \sum _ { \tau } \left. \pmb { g } _ { \tau } \right. ^ { - 1 } = \left[ \left( T - 1 \right) C _ { 1 } + 1 \right] / \sum _ { \tau } \left. \pmb { g } _ { \tau } \right. ^ { - 1 } = C _ { 2 } .
+$$
+
+From Eq. (12) we know the solution $\left\{ \alpha _ { t } \right\}$ of IMTL-G is unique, so it must be the one given by Eq. (20) where $\{ \alpha _ { t } > 0 \}$ , so the lemma is proved. □
+
+Then we prove Theorem 1 which states that IMTL-G leads to the same solution as GradNorm when the angle between any pair of gradients $\left\{ \pmb { g } _ { t } \right\}$ is identical: $\mathbf { \boldsymbol { u } } _ { t } \mathbf { \boldsymbol { u } } _ { \tau } ^ { \top } = C _ { 1 } , \ \forall t \neq \tau$ .
+
+Proof. $\Rrightarrow$ Necessity) Given constant projections in IMTL-G, we have:
+
+$$
+{ \pmb g } { \pmb u } _ { t } ^ { \top } = \left( \sum _ { \tau } \alpha _ { \tau } { \pmb g } _ { \tau } \right) { \pmb u } _ { t } ^ { \top } = C _ { 2 } .
+$$
+
+Recall that $\pmb { u } _ { t } = \pmb { g } _ { t } / \left\| \pmb { g } _ { t } \right\|$ and $\mathbf { \boldsymbol { u } } _ { t } \mathbf { \boldsymbol { u } } _ { \tau } ^ { \top } = C _ { 1 } , \ \forall t \neq \tau$ . From Lemma 3 we know that $\left\{ \alpha _ { t } \right\}$ given by IMTL-G must satisfy $\{ \alpha _ { t } > 0 \}$ . If we assume $n _ { t } = \| \alpha _ { t } \pmb { g } _ { t } \|$ , then we know $\alpha _ { t } \pmb { g } _ { t } = n _ { t } \pmb { u } _ { t }$ and:
+
+$$
+\sum _ { \tau } n _ { \tau } \pmb { u } _ { \tau } \pmb { u } _ { t } ^ { \top } = \sum _ { \tau \neq t } n _ { \tau } C _ { 1 } + n _ { t } = C _ { 2 } .
+$$
+
+Now we obtain:
+
+$$
+\sum _ { \tau \neq t } n _ { \tau } C _ { 1 } + n _ { t } = \sum _ { \tau } n _ { \tau } C _ { 1 } + \left( 1 - C _ { 1 } \right) n _ { t } = C _ { 2 } .
+$$
+
+As $C _ { 1 } < 1$ , we can then prove $n _ { t } = C _ { 3 }$ , $\forall t$ . It implies the norm of the scaled gradient is constant, which is requested by GradNorm (Chen et al., 2018). Moreover, we can obtain the relationship among constants from Eq. (24):
+
+$$
+C _ { 1 } T C _ { 3 } + \left( 1 - C _ { 1 } \right) C _ { 3 } = C _ { 2 } \Rightarrow C _ { 3 } = \frac { C _ { 2 } } { \left( T - 1 \right) C _ { 1 } + 1 } .
+$$
+
+( $\Leftarrow$ Sufficiency) In GradNorm, $\left\{ \alpha _ { t } \right\}$ are always chosen to satisfy $\{ \alpha _ { t } > 0 \}$ , so if we assume $n _ { t } =$ $\| \alpha _ { t } \pmb { g } _ { t } \|$ , then given the constant norm of the scaled gradient in GradNorm, we have:
+
+$$
+\alpha _ { t } { \pmb g } _ { t } = n _ { t } { \pmb u } _ { t } = C _ { 3 } { \pmb u } _ { t } ,
+$$
+
+where $\pmb { u } _ { t } = \pmb { g } _ { t } / \left\| \pmb { g } _ { t } \right\|$ . As we have $\begin{array} { r } { \pmb { g } = \sum _ { t } \alpha _ { t } \pmb { g } _ { t } } \end{array}$ and $\mathbf { \boldsymbol { u } } _ { t } \mathbf { \boldsymbol { u } } _ { \tau } ^ { \top } = C _ { 1 } , \ \forall t \neq \tau$ , then we obtain:
+
+$$
+g \pmb { u } _ { t } ^ { \top } = \left( \sum _ { \tau } \alpha _ { \tau } g _ { \tau } \right) \pmb { u } _ { t } ^ { \top } = \left( \sum _ { \tau } C _ { 3 } \pmb { u } _ { \tau } \right) \pmb { u } _ { t } ^ { \top } = C _ { 3 } \left[ \left( T - 1 \right) C _ { 1 } + 1 \right] = C _ { 2 } .
+$$
+
+It means the projections of $\textbf {  { g } }$ onto $\left\{ \pmb { g } _ { t } \right\}$ are constant, which is requested by our IMTL-G.
+
+Corollary 4. In GradNorm, if the solution $\left\{ \alpha _ { t } \right\}$ satisfies $\textstyle \sum _ { t } \alpha _ { t } = 1$ , then its constants are given by $\begin{array} { r } { C _ { 3 } = 1 / \sum _ { t } \| { \pmb g } _ { t } \| ^ { - 1 } } \end{array}$ and $\begin{array} { r } { C _ { 2 } = \left[ \left( T - 1 \right) C _ { 1 } + 1 \right] / \sum _ { t } { \| { \pmb g } _ { t } \| } ^ { - 1 } } \end{array}$ , and its scaling factors are given by $\left\{ { \alpha _ { t } } = \left\| { { g _ { t } } } \right\| ^ { - 1 } / \sum _ { \tau } \left\| { { g _ { \tau } } } \right\| ^ { - 1 } \right\}$ .
+
+Proof. By using $\alpha _ { t } ~ = ~ C _ { 3 } / \left\| g _ { t } \right\|$ from Eq. (26), we have $\begin{array} { r } { \sum _ { t } C _ { 3 } / \left| \left| \pmb { g } _ { t } \right| \right| \ = \ 1 } \end{array}$ , then $C _ { 3 } \ =$ $1 / \textstyle \sum _ { t } \| g _ { t } \| ^ { - 1 }$ , and also we have $\begin{array} { r } { \alpha _ { t } = \left. \pmb { g } _ { t } \right. ^ { - 1 } / \sum _ { \tau } \left. \pmb { g } _ { \tau } \right. ^ { - 1 } } \end{array}$ . As the relationship of $C _ { 2 }$ and $C _ { 3 }$ from Eq. (27) is given by $C _ { 3 } \left[ \left( T - 1 \right) C _ { 1 } + 1 \right] = C _ { 2 }$ , so $\begin{array} { r } { C _ { 2 } = \left[ \left( T - 1 \right) C _ { 1 } + 1 \right] / \sum _ { t } { \left. { \pmb g _ { t } } \right. ^ { - 1 } } } \end{array}$ .
+
+# C.2 CLOSED-FORM SOLUTION OF MGDA
+
+In our relaxed MGDA (Sener & Koltun, 2018) without $\{ \alpha _ { t } \geqslant 0 \}$ , finding $\begin{array} { r } { \mathbf { \phi } \mathbf { g } = \sum _ { t } \alpha _ { t } \mathbf { g } _ { t } } \end{array}$ with $\textstyle \sum _ { t } \alpha _ { t } = 1$ such that $\textbf {  { g } }$ has minimum norm is equivalent to find the normal vector of the hyperplane composed by $\left\{ \pmb { g } _ { t } \right\}$ . So we let $\textbf {  { g } }$ to be perpendicular to all of $\{ g _ { 1 } - g _ { t } \}$ on the hyper-plane:
+
+$$
+g \perp \left( g _ { 1 } - g _ { t } \right) \Leftrightarrow g \left( g _ { 1 } - g _ { t } \right) ^ { \top } = 0 , \forall 2 \leqslant t \leqslant T .
+$$
+
+If we set ${ \pmb { \alpha } } = [ \alpha _ { 2 } , \cdots , \alpha _ { T } ]$ and $G ^ { \top } = \left[ \pmb { g } _ { 2 } ^ { \top } , \cdots , \pmb { g } _ { T } ^ { \top } \right]$ , then we have $\alpha _ { 1 } = 1 - 1 \alpha ^ { \top }$ , and Eq. (28) can be expanded as:
+
+$$
+\left( \sum _ { t } \alpha _ { t } g _ { t } \right) \left[ \begin{array} { l l l l } { g _ { 1 } ^ { \top } - g _ { 2 } ^ { \top } , } & { \cdots } & { , g _ { 1 } ^ { \top } - g _ { T } ^ { \top } } \end{array} \right] = \mathbf { 0 } \Leftrightarrow \left[ \begin{array} { l l } { 1 - \mathbf { 1 } \alpha ^ { \top } , } & { \alpha } \end{array} \right] \left[ \begin{array} { l } { g _ { 1 } } \\ { G } \end{array} \right] D ^ { \top } = \mathbf { 0 } ,
+$$
+
+where $\pmb { { \cal D } } ^ { \top } = \left[ \pmb { { \pmb { g } } } _ { 1 } ^ { \top } - \pmb { { \mathscr { g } } } _ { 2 } ^ { \top } , \cdots , \pmb { { \mathscr { g } } } _ { 1 } ^ { \top } - \pmb { { \mathscr { g } } } _ { T } ^ { \top } \right]$ , 1 and 0 indicates the all-one and all-zero row vector. Eq. (29) can be represented as:
+
+$$
+\left[ \left( 1 - \mathbf { 1 } \alpha ^ { \top } \right) \boldsymbol { g } _ { 1 } + \alpha \boldsymbol { G } \right] \boldsymbol { D } ^ { \top } = \mathbf { 0 } \Leftrightarrow \alpha \left( \mathbf { 1 } ^ { \top } \boldsymbol { g } _ { 1 } - \boldsymbol { G } \right) \boldsymbol { D } ^ { \top } = \boldsymbol { g } _ { 1 } \boldsymbol { D } ^ { \top } .
+$$
+
+As we also have ${ \pmb { D } } = { \bf 1 } ^ { \top } { \pmb { g } } _ { 1 } - { \pmb { G } }$ , then the closed-form solution of $_ { \pmb { \alpha } }$ is given by:
+
+$$
+\alpha D D ^ { \top } = g _ { 1 } D ^ { \top } \Leftrightarrow \alpha = g _ { 1 } D ^ { \top } \left( D D ^ { \top } \right) ^ { - 1 } .
+$$
+
+Bias of MGDA. In the main text we state that MGDA focuses on tasks with small gradient magnitudes, where we relaxed MGDA by not constraining $\{ \alpha _ { t } \geqslant 0 \}$ . However, even with these constraints, the problem still exists. For example in the context of two tasks, assume $\left\| g _ { 1 } \right\| < \left\| g _ { 2 } \right\|$ , if the minimum-norm point of $\textbf {  { g } }$ satisfying ${ \pmb g } = \alpha { \pmb g } _ { 1 } + ( 1 - \alpha ) { \pmb g } _ { 2 }$ is outside the convex hull composed by $\left\{ g _ { 1 } , g _ { 2 } \right\}$ , or equivalently $\alpha > 1$ , MGDA clamps $\alpha$ to $\alpha = 1$ and the optimal $\pmb { g } ^ { \star } = \pmb { g } _ { 1 }$ . Then the projections of $\pmb { g } ^ { \star }$ onto $\pmb { g } _ { 1 }$ and $\mathbf { \delta } _ { \mathbf { { \boldsymbol { g } } } 2 }$ will be $\left\| g _ { 1 } \right\|$ and $\mathbf { \Lambda } _ { g _ { 1 } u _ { 2 } ^ { \top } }$ $( { \pmb u } _ { 2 } = { \pmb g } _ { 2 } / \| { \pmb g } _ { 2 } \| )$ , respectively. As $\lvert | \mathbf { \boldsymbol { g } } _ { 1 } \rvert | > \left. \mathbf { \boldsymbol { g } } _ { 1 } \mathbf { \boldsymbol { u } } _ { 2 } ^ { \intercal } \right.$ , so MGDA still focuses on tasks with smaller gradient magnitudes.
+
+# C.3 ANALYSIS OF PCGRAD
+
+PCGrad (Yu et al., 2020) mitigates the gradient conflicts by projecting the gradient of one task to the orthogonal direction of the others, and the aggregated gradient can be written as:
+
+$$
+\pmb { g } = \sum _ { t } \left( \pmb { g } _ { t } + \sum _ { \tau } C _ { t \tau } \pmb { u } _ { \tau } \right) ,
+$$
+
+with $\pmb { u } _ { t } = \pmb { g } _ { t } / \left\| \pmb { g } _ { t } \right\|$ and the coefficients:
+
+$$
+C _ { t t } = 0 , \ C _ { t \tau } = \left[ - \ \left( g _ { t } + \sum _ { t ^ { \prime } < \tau , } C _ { t t ^ { \prime } } { \pmb u } _ { t ^ { \prime } } \right) { \pmb u } _ { \tau } ^ { \top } \right] _ { + } , \forall t , \tau ,
+$$
+
+where $[ \cdot ] _ { + }$ means the ReLU operator. Note that the tasks have been shuffled before calculating the aggregated gradient $\textbf {  { g } }$ to achieve expected symmetry with respect to the task order. Eq. (31) can be represented more compactly in the matrix form:
+
+$$
+g = { \bf 1 } \left( I _ { T } + C N \right) G \equiv \alpha G ,
+$$
+
+where ${ \cal I } _ { T }$ is the identity matrix, $C = \{ C _ { t \tau } \}$ is the coefficient matrix whose entries are given in Eq. (32) and ${ \cal N } = \mathrm { d i a g } ( \mathrm { i } / \| g _ { 1 } \| , \cdot \cdot \cdot , 1 / \widetilde { \| } g _ { T } \widetilde { \| } )$ is the diagonal normalization matrix. In Eq. (33) we use $G$ and $_ \alpha$ to denote the raw gradients and scaling factors of all tasks. We find that PCGrad can also be regarded as loss weighting, with the loss weights given by $\pmb { \alpha } = \mathbf { 1 } \left( \pmb { I _ { T } } +\pmb { C N } \right)$ . However, it still may break the balance among tasks. For example with two tasks, assume the angle between the gradients is $\phi \colon 1$ ) when $\pi / 2 \leqslant \phi < \pi$ , then $\pmb { C } = \left[ \begin{array} { c c } { 0 } & { - \pmb { g } _ { 1 } \pmb { g } _ { 2 } ^ { \top } / \left. \pmb { g } _ { 2 } \right. } \\ { - \pmb { g } _ { 1 } \pmb { g } _ { 2 } ^ { \top } / \left. \pmb { g } _ { 1 } \right. } & { 0 } \end{array} \right]$ and the projections onto the two raw gradients are $\left\| g _ { 1 } \right\| \sin ^ { 2 } \phi$ and $\| g _ { 2 } \| \sin ^ { 2 } \phi ; 2 )$ when $0 < \phi < \pi / 2$ , then $C = \mathbf { 0 }$ and the projections are $\| \pmb { g } _ { 1 } \| + \| \pmb { g } _ { 2 } \| \cos \phi$ and $\| \pmb { g } _ { 2 } \| + \| \pmb { g } _ { 1 } \| \cos \phi$ . In both cases, the projections are equal if and only if $\| g _ { 1 } \| = \| g _ { 2 } \|$ . Otherwise, the task with larger gradient magnitude will be trained more sufficiently, which may encounter the same problem as uniform scaling that na¨ıvely adds all the losses despite that the loss scales are highly different.
+
+# C.4 $L _ { 2 }$ LOSS IN UNCERTAINTY WEIGHTING
+
+For regression, uncertainty weighting (Kendall et al., 2018) regards the $L _ { 2 }$ loss as likelihood estimation on the sample target which follows the Gaussian distribution:
+
+$$
+- \log p \left( { y } \mid { f } \left( { \pmb x } \right) \right) = \frac { 1 } { 2 } \left( \frac { 1 } { \sigma ^ { 2 } } \left\| { y } - { f } \left( { \pmb x } \right) \right\| _ { 2 } ^ { 2 } + \log { \sigma ^ { 2 } } \right) ,
+$$
+
+where $_ { \textbf { \em x } }$ is the data sample, $y$ is the ground-truth label, $f$ denotes the prediction model and $\sigma$ is the standard deviation of Gaussian distribution. By setting $s = - \log { \sigma ^ { 2 } }$ , the scaled $L _ { 2 }$ loss is $\begin{array} { r } { L = \frac { 1 } { 2 } \left( e ^ { s } L _ { \mathrm { r e g } } - s \right) } \end{array}$ , which has a similar form as the scaled $L _ { 1 }$ loss except the front factor $1 / 2$ . So uncertainty weighting has difficulty in reaching a unified form for all kinds of losses, which is less general than our IMTL-L.
+
+# C.5 GRADIENT OF GEOMETRIC MEAN
+
+GLS (Chennupati et al., 2019) computes the loss as the geometric mean, its gradient with respect to model parameters are:
+
+$$
+\begin{array} { l } { { \displaystyle \nabla _ { \theta } L = \frac { 1 } { T } \left( \prod _ { t } L _ { t } \right) ^ { \frac { 1 } { T } - 1 } \sum _ { t } \left[ \left( \prod _ { \tau \neq t } L _ { \tau } \right) \nabla _ { \theta } L _ { t } \right] } } \\ { { \displaystyle ~ = \frac { 1 } { T } \left( \prod _ { t } L _ { t } \right) ^ { \frac { 1 } { T } } \sum _ { t } \frac { \nabla _ { \theta } L _ { t } } { L _ { t } } = \frac { L } { T } \sum _ { t } \frac { 1 } { L _ { t } } \left( \nabla _ { \theta } L _ { t } \right) . } } \end{array}
+$$
+
+where $L$ is the geometric mean loss and $T$ is the task number. It is equivalent to weigh the taskspecific loss with its reciprocal value, except that there exists another term $L / T$ in the front where $L = ( \prod _ { t } L _ { t } ) ^ { \frac { 1 } { T } }$ , so GLS is sensitive to the loss scale changes of $\{ L _ { t } \}$ and not scale-invariant.
+
+# D IMPLEMENTATION DETAILS
+
+To solely compare the loss weighting methods, we fix the network structure and choose ResNet50 (He et al., 2016) with dilation (Chen et al., 2017) and synchronized (Peng et al., 2018) batch normalization (Ioffe & Szegedy, 2015) as the shared backbone and PSPNet (Zhao et al., 2017) as the task-specific head, and the backbone model weights are pretrained on ImageNet (Deng et al., 2009). Following the common practice of semantic segmentation, in training we adopt augmentations as random resize (between 0.5 to 2), random rotate (between -10 to 10 degrees), Gaussian blur (with a radius of 5) and random horizontal flip. Besides, we apply strided cropping and horizontal flipping as testing augmentations. The predicted results in the overlapped region of different crops are averaged to obtain the aggregated prediction of the whole image. Only pixels with ground truth labels are included in loss and metric computation, while others are ignored. Semantic segmentation, instance segmentation, surface normal estimation and disparity/depth estimation are considered. As for the losses/metrics, semantic segmentation uses cross-entropy/mIoU, surface normal estimation adopts $( 1 - \cos ) /$ /cosine similarity and both instance segmentation and disparity/depth estimation use $L _ { 1 }$ loss. We use polynomial learning rate with a power of 0.9, SGD with a momentum of 0.9 and weight decay of $1 0 ^ { - 4 }$ as the optimizer, with the model trained for 200 epochs. After passing through the shared backbone where strided convolutions exist, the feature maps have $1 / 8$ size as that of the input image. Then the results predicted by PSPNet (Zhao et al., 2017) heads are up-sampled to the original image size for loss and metric computation.
+
+![](images/8ed1ae979f1abda875996e83cb8a3382f566b08774c382eebd1b44591d21a53b.jpg)  
+Figure 5: Pipeline used in the Cityscapes visual understanding experiment. The centroids are computed from the offset regression results. Each pixel is assigned to its nearest candidate centroid.
+
+For the Cityscapes dataset, the batch size is 32 ( $2 \times 1 6$ GPUs) with the initial learning rate 0.02. We train on the 2975 training images and validate on the 500 validation images $( 1 0 2 4 \times 2 0 4 8$ full resolution) where ground truth labels are provided. Three tasks are considered, namely semantic segmentation, instance segmentation and disparity/depth estimation. Training and testing are done on $7 1 3 \times 7 1 3$ crops. Semantic segmentation is to differentiate among the commonly used 19 classes. Instance segmentation is taken as offset regression, where each pixel $\pmb { p } _ { i } = ( x _ { i } , y _ { i } )$ approximates the relative offset $o _ { i } = ( \mathrm { d } x _ { i } , \mathrm { d } y _ { i } )$ with respect to the centroid $\pmb { c } _ { \mathrm { i d } ( \pmb { p } _ { i } ) }$ of its belonging instance id $\left( { { p } _ { i } } \right)$ . To conduct inference, we abandon the time-consuming and complicated clustering methods adopted by the previous method (Kendall et al., 2018). Instead, we directly use the offset vectors $\left\{ o _ { i } \right\}$ predicted by the model to find the centroids of instances. By definition, the norm of a centroid’s offset vector should be 0, so we can transform the offset vector norm $\| o _ { i } \|$ to the probability $q _ { i }$ of being a centroid with the exponential function $q _ { i } = e ^ { - \| \mathbf { o } _ { i } \| }$ . Next a $7 \times 7$ edge filter is applied on the centroid probability map to filter out the spurious centroids on object edges resulting from the regression target ambiguity. The locations with centroid probability $q _ { i } < 0 . 1$ are also manually suppressed. Then $7 \times 7$ max-pooling on the filtered probability map is used to produce candidate centroids and filter out duplicate ones. With the predicted centroids $\{ c _ { i } \}$ , we can then assign each pixel $\mathbf { \nabla } p _ { i }$ to its belonging instance id $\left( { { { p } _ { i } } } \right)$ by the distance between its approximated centroids $\pmb { p } _ { i } + \pmb { o } _ { i }$ and the candidate centroids $\left\{ c _ { i } \right\}$ : id $\begin{array} { r } { ( \pmb { p _ { i } } ) = \arg \operatorname* { m i n } _ { j } \| \pmb { p _ { i } } + \pmb { o _ { i } } - \pmb { c _ { j } } \| } \end{array}$ . Depth is measured in pixels by the disparity between the left and right images. Fig. 5 shows the whole process. Note that we need to carefully deal with label transformation during data augmentation. For example, disparity ground truth needs to be up-scaled by $s$ times if the image is up-sampled by $s$ times. Also, the predicted offset vectors of the flipped input should be mirrored to comply with the normal one.
+
+On the NYUv2 dataset, the batch size is 48 ( $6 \times 8$ GPUs) with the initial learning rate 0.03. We use the 795 training images for training and the 654 validation images for testing with $4 8 0 \times 6 4 0$ full resolution. $4 0 1 \times 4 0 1$ crops are used for training and testing. 13 coarse-grain classes are considered in semantic segmentation. The surface normal is represented by the unit normal vector of the corresponding surface. When doing data augmentation, surface normal ground truth $\textbf { \em n } =$ $( x , y , z )$ should be processed accordingly. If we resize the image by $s$ times, the $z$ coordinate of the normal vector should be scaled by $s$ and renormalized: $\pmb { n } ^ { \prime } = \left( x , y , s z \right) / \left\| \left( x , y , s z \right) \right\|$ . If the image is rotated by the rotation matrix $\pmb { R }$ , the normal vector should also be in-plane rotated $( x ^ { \prime } , y ^ { \prime } ) \overset { \mathbf { \bar { \mathbf { \theta } } } } { = } \left( x , y \right) R ^ { \top }$ with $z$ unchanged. Moreover, the left-right flip should be applied on the normal vector $\pmb { n } ^ { \prime } = ( - x , y , z )$ when mirroring the image horizontally. During testing, the normal vectors in the overlapped region of crops are averaged and renormalized to produce the aggregated results. Depth is the absolute distance to the camera and measured by meters, which is inverse-proportional to the disparity measurement adopted by Cityscapes. So the depth in meters needs to be scaled by $1 / s$ when the image is scaled by $s$ times, which is the reciprocal of disparity transformation.
+
+CelebA contains 202,599 face images from 10,177 identities, where each image has 40 binary attribute annotations. We train on the 162,770 training images and test on the 19,867 validation images. Most of the implementation details are the same as those on the Cityscapes dataset, except that: 1) we employ the ResNet-18 as the backbone and linear classifiers as the task-specific heads, so totally 40 heads are attached on the backbone ; 2) the binary-cross entropy is used as the classification loss for each attribute; 3) the batch size is 256 $3 2 \times 8$ GPUs) and the model is trained from scratch for 100 epochs; 4) the input image has been aligned with the annotated 5 landmarks and cropped to $2 1 8 \times 1 7 8$ .
+
+E QUALITATIVE RESULTS
+
+![](images/e80057bf640bab9268a4ae49a7aea82686beec4952e45caa6cbabd950cbfd43b.jpg)  
+Figure 6: Qualitative comparisons between our IMTL and previous methods on Cityscapes.
+
+![](images/9e225b6f3bfa4fb2cc7a9a36e38a6ac6948bb099795bdd03a79b88f51b3bf200.jpg)  
+Figure 7: Qualitative results of our IMTL on Cityscapes. Semantic segmentation, instance segmentation and disparity estimation predictions are produced by a single network. The task-shared backbone is ResNet-50 and the task-specific heads are PSPNet. The image resolution is $1 0 2 4 \times 2 0 4 8$ .
+
+![](images/329043f98947ba54266311c34e7c5a852929a868f85aadad491b83016d6ba466.jpg)  
+Figure 8: Qualitative results of our IMTL on NYUv2. Semantic segmentation, surface normal estimation and depth estimation predictions are produced by a single network. The task-shared backbone is ResNet-50 and the task-specific heads are PSPNet. The image resolution is $4 8 0 \times 6 4 0$ .

parse/train/SJeLopEYDH/SJeLopEYDH.md

@@ -0,0 +1,274 @@
+# V4D:4D CONVOLUTIONAL NEURAL NETWORKS FOR VIDEO-LEVEL REPRESENTATION LEARNING
+
+Shiwen Zhang, Sheng Guo, Weilin Huang∗ & Matthew R. Scott
+
+Malong Technologies, Shenzhen, China Shenzhen Malong Artificial Intelligence Research Center, Shenzhen, China {shizhang,sheng,whuang,mscott}@malong.com
+
+Limin Wang   
+State Key Laboratory for Novel Software Technology, Nanjing University, China   
+lmwang@nju.edu.cn
+
+# ABSTRACT
+
+Most existing 3D CNNs for video representation learning are clip-based methods, and thus do not consider video-level temporal evolution of spatio-temporal features. In this paper, we propose Video-level 4D Convolutional Neural Networks, referred as V4D, to model the evolution of long-range spatio-temporal representation with 4D convolutions, and at the same time, to preserve strong 3D spatio-temporal representation with residual connections. Specifically, we design a new 4D residual block able to capture inter-clip interactions, which could enhance the representation power of the original clip-level 3D CNNs. The 4D residual blocks can be easily integrated into the existing 3D CNNs to perform long-range modeling hierarchically. We further introduce the training and inference methods for the proposed V4D. Extensive experiments are conducted on three video recognition benchmarks, where V4D achieves excellent results, surpassing recent 3D CNNs by a large margin.
+
+# 1 INTRODUCTION
+
+3D convolutional neural networks (3D CNNs) and their variants (Ji et al., 2010; Tran et al., 2015; Carreira & Zisserman, 2017; Qiu et al., 2017; Wang et al., 2018b) provide a simple extension from 2D counterparts for video representation learning. However, due to practical issues such as memory consumption and computational cost, these models are mainly used for clip-level feature learning instead of learning from the whole video. The clip-based methods randomly sample a short clip (e.g., 32 frames) from a video for representation learning, and calculate prediction scores for each clip independently. The prediction scores of all clips are simply averaged to yield the video-level prediction. These clip-based models often ignore the video-level structure and long-range spatiotemporal dependency during training, as they only sample a small portion of the entire video. In fact, in some cases, it could be difficult to identify an action correctly by only using partial observation. Meanwhile, simply averaging the prediction scores of all clips could be sub-optimal during inference. To overcome this issue, Temporal Segment Network (TSN) (Wang et al., 2016) was proposed. TSN uniformly samples multiple clips from the entire video, and the average scores are used to guide back-propagation during training. Thus TSN is a video-level representation learning framework. However, the inter-clip interaction and video-level fusion in TSN is only performed at very late stage, which fails to capture finer temporal structures.
+
+In this paper, we propose a general and flexible framework for video-level representation learning, called V4D. As shown in Figure 1, to model long-range dependency in a more efficient way, V4D is composed of two critical designs: (1) holistic sampling strategy, and (2) 4D convolutional interaction. We first introduce a video-level sampling strategy by uniformly sampling a sequence of short-term units covering the whole video. Then we model long-range spatio-temporal dependency by designing a unique 4D residual block. Specifically, we present a 4D convolutional operation to capture inter-clip interaction, which could enhance the representation power of the original clip-level 3D CNNs. The 4D residual blocks could be easily integrated into the existing 3D CNNs to perform long-range modeling hierarchically, which is more efficient than TSN. We also design a specific video-level inference algorithm for V4D. Finally, we verify the effectiveness of V4D on three video action recognition benchmarks, Mini-Kinetics (Xie et al., 2018), Kinetics-400 (Carreira & Zisserman, 2017) and Something-Something-V1 (Goyal et al., 2017). Our V4D achieves very competitive performance on the three benchmarks, and obtains evident performance improvement over its 3D counterparts.
+
+# 2 RELATED WORKS
+
+Two-stream CNNs. Two-stream architecture was originally proposed by (Simonyan & Zisserman, 2014), where one stream is used for learning from RGB images, and the other one is applied to model optical flow. The results produced by the two streams are then fused at later stages, yielding the final prediction. Two-stream CNNs have achieved impressive results on various video recognition tasks. However, the main limitation is that the computation of optical flow is highly expensive where parallel optimization is difficult to implment, with significant resource explored. Recent effort has been devoted to reducing the computational cost on modeling optical flow, such as (Dosovitskiy et al., 2015; Sun et al., 2018; Piergiovanni & Ryoo, 2018; Zhang et al., 2016). The two-stream design is a general framework to boost the performance of various CNN models, which is orthogonal to the proposed V4D.
+
+3D CNNs. Recently, 3D CNNs have been proposed (Tran et al., 2015; Carreira & Zisserman, 2017; Wang et al., 2018a;b; Feichtenhofer et al., 2018). By considering a video as a stack of frames, it is natural to develop 3D convolutions applied directly on video sequence. However, 3D CNNs often introduce a large number of model parameters, which inevitably require a large amount of training data to achieve good performance. As reported in (Wang et al., 2018b; Feichtenhofer et al., 2018), recent experimental results on large-scale benchmark, likes Kinetics-400 (Carreira & Zisserman, 2017), show that 3D CNNs can surpass their 2D counterparts in many cases,and even can be on par with or better than the two-stream 2D CNNs. It is noteworthy that most of 3D CNNs are clip-based methods, which only explore a certain part of the holistic video.
+
+Long-term Modeling Framework. Various long-term modeling frameworks have been developed for capturing more complex temporal structure for video-level representation learning. In (Laptev et al., 2008), video compositional models were proposed to jointly model local video events, where temporal pyramid matching was introduced with a bag-of-visual-words framework to compute longterm temporal structure. However, the rigid composition only works under defined constraints, e.g., prefixed duration and anchor points provided in time. A mainstream method is to process a continuous video sequence with recurrent neural networks $\mathrm { N g }$ et al. (2015); Donahue et al. (2015), where 2D CNNs are used for frame-level feature extraction. Temporal Segment Network (TSN) (Wang et al., 2016) has been proposed to model video-level temporal information with a sparse sampling and aggregation strategy. TSN sparsely samples a set of frames from the whole video, and then the sampled frames are modelled by the same CNN backbone, which outputs a confident score for each frame. The output scores are averaged to generate final video-level prediction. TSN was originally designed for 2D CNNs, but it can be applied to 3D CNNs, which serves as one of the baselines in this paper. One of the main limitations of TSN is that it is difficult to model finer temporal structure due to the average aggregation. Temporal Relational Reasoning Network (TRN) (Zhou et al., 2018) was introduced to model temporal segment relation by encoding individual representation of each segment with relation networks. TRN is able to model video-level temporal order but lacks the capacity of capturing finer temporal structure. The proposed V4D can outperform these previous video-level learning methods on both appearance-dominated video recognition (e.g., on Kinetics) and motion-dominated video recognition (e.g., on Something-Something). It is able to model both short-term and long-term temporal structure with a unique design of 4D residual blocks.
+
+# 3 VIDEO-LEVEL 4D COVOLUTIONAL NEURAL NETWORKS
+
+In this section, we introduce new Video-level 4D Convolution Neural Networks, namely V4D, for video action recognition. This is the first attempt to design 4D convolutions for RGB-based video recognition. Previous methods, such as You & Jiang (2018); Choy et al. (2019), utilize 4D CNNs to process videos of point cloud by using 4D data as input. Instead, our V4D processes videos of RGB frames with input of 3D data. Existing 3D CNNs often take a short-term snippet as input, without considering the evolution of 3D spatio-temporal features for video-level representation. In Wang et al. (2018b); Yue et al. (2018); Liu et al. (2019), self-attention mechanism was developed to model non-local spatio-temporal features, but these methods were originally designed for clip-based 3D CNNs. It remains unclear how to incorporate such operations on holistic video representation, and whether such operations are useful for video-level representation learning. Our goal is to model 3D spatio-temporal features globally, which can be implemented in a higher dimension. In this work, we introduce new Residual 4D Blocks, which allow us to cast 3D CNNs into 4D CNNs for learning long-range interactions of the 3D features, resulting in a “time of time” video-level representation.
+
+![](images/fa8425da7f07f6416ac6b0c97065c8f4e1bd6975e14cc1333aeafa20d3b3241e.jpg)  
+Figure 1: Video-level 4D Convolutional Neural Networks for video recognition.
+
+# 3.1 A VIDEO-LEVEL SAMPLING STRATEGY
+
+To model meaningful video-level representation for action recognition, the input to the networks has to cover the holistic duration of a given video, and at the same time preserve short-term action details. A straightforward approach is to implement per-frame training of the networks yet this is not practical by considering the limit of computation resource. In this work, we uniformly divide the whole video into $U$ sections, and select a snippet from each section to represent a short-term action pattern, called “action unit”. Then we have $U$ action units to represent the holistic action in a video. Formally, we denote the video-level input $V = \{ A _ { 1 } , A _ { 2 } , . . . , \tilde { A _ { U } } \}$ , where $A _ { i } \in \mathbb { R } ^ { C \times T \times H \times W }$ . During training, each action unit $A _ { i }$ is randomly selected from each of the $U$ sections. During testing, the center of each $A _ { i }$ locates exactly at the center of the corresponding section.
+
+# 2 4D CONVOLUTIONS FOR LEARNING SPATIO-TEMPORAL INTERACTION
+
+3D Convolutional kernels have been proposed, and are powerful to model short-term spatio-temporal features. However, the receptive fields of 3D kernels are often limited due to the small sizes of kernels, and pooling operations are applied to enlarge the receptive fields, resulting in a significant cost of information loss. This inspired us to develop new operations which are able to model both short- and long-term spatio-temporal representations simultaneously, with easy implementations and fast training. From this prospective, we propose 4D convolutions for better modeling the long-range spatio-temporal interactions.
+
+Specifically, we denote the input to 4D convolutions as a tensor $V$ of size $( C , U , T , H , W )$ , where $C$ is number of channel, $U$ is the number of action units (the 4-th dimension in this paper), $T , H , W$ are temporal length, height and width of an action unit. We omit the batch dimension for simplicity. By following the annotations provided in Ji et al. (2010), a pixel at position $( u , t , h , w )$ of the $j$ th channel in the output is denoted as $o _ { j } ^ { u t h w }$ , and a 4D convolution operation can be formulated as :
+
+$$
+o _ { j } ^ { u t h w } = b _ { j } + \sum _ { c } ^ { C _ { i n } } \sum _ { s = 0 } ^ { S - 1 } \sum _ { p = 0 } ^ { P - 1 } \sum _ { q = 0 } ^ { Q - 1 } \sum _ { r = 0 } ^ { R - 1 } \mathcal { W } _ { j c } ^ { s p q r } v _ { c } ^ { ( u + s ) ( t + p ) ( h + q ) ( w + r ) }
+$$
+
+where $S \times P \times Q \times R$ $b _ { j }$ is a bias term, in is the shape of 4D convolutional kernel, is one of the $C _ { i n }$ input channels of the feature maps from input $\mathcal { W } _ { j c } ^ { s p q r }$ is the weight at the position $( s , p , q , r )$ $V$ , of the kernel, corresponding to the $c$ -th channel of the input feature maps and $j$ -th channel of the output feature maps.
+
+![](images/732309d3a94b05e6a4a3e5041b903bcf639a21cff162c6af86bbfd04d3b626d8.jpg)  
+Figure 2: Implementation of 4D kernels, compared to3D kernel s. $U$ denotes the number of action units, with shape of $T , H , W$ . Channel and batch dimensions are omitted for clarity. The kernels are colored in Blue, with the center of each kernel colored in Green.
+
+Convolutional operation is linear, and the sequential sum operations in E.q. 1 are exchangeable. Thus we can generate E.q. 2, where the expression in the parentheses can be implemented by 3D convolutions, allowing us to implement 4D convolutions using 3D convolutions, while most deep learning libraries do not directly provide 4D convolutional operations.
+
+$$
+o _ { j } ^ { u t h w } = b _ { j } + \sum _ { s = 0 } ^ { S - 1 } ( \sum _ { c } \sum _ { p = 0 } ^ { C _ { i n } } \sum _ { q = 0 } ^ { Q - 1 } \sum _ { r = 0 } ^ { R - 1 } \mathcal { W } _ { j c } ^ { s p q r } v _ { c } ^ { ( u + s ) ( t + p ) ( h + q ) ( w + r ) } )
+$$
+
+With the 4D convolutional kernel, the short-term 3D features of an individual action unit and longterm temporal evolution of multiple action units can be modeled simultaneously in the 4D space. Compared to 3D convolutions, the proposed 4D convolutions are able to model videos in a more meaningful 4D feature space that enables it to learn more complicated interactions of long-range 3D spatio-temporal representation. However, 4D convolutions inevitably introduce more parameters and computation cost. For example, a 4D convolutional kernel of $k \times k \times k \times k$ employs $k$ times more parameters than a 3D kernel of $k \times k \times k$ . In practice, we explore $k \times k \times 1 \times 1$ and $k \times 1 \times 1 \times 1$ kernels, to reduce the parameters and avoid the risk of overfitting. The implementation of different kernels is shown in Figure 2.
+
+# 3.3 VIDEO-LEVEL 4D CNN ARCHITECTURE
+
+In this section, we demonstrate that our 4D convolutions can be integrated into existing CNN architecture for action recognition. To fully utilize current state-of-the-art 3D CNNs, we propose a new Residual 4D Convolution Block, by designing a 4D convolution in the residual structure introduced in (He et al., 2016). This allows it to aggregate both short-term 3D features and long-term evolution of the spatio-temporal representations for video-level action recognition. Specifically, we define a permutation function $\varphi _ { ( d _ { i } , d _ { j } ) } : M ^ { d _ { 1 } \times . . . \times d _ { i } \times . . . \times d _ { j } \times . . . \times d _ { n } } \mapsto M ^ { d _ { 1 } \Breve { \times } . . . \times d _ { j } \times . . . \hslash d _ { i } \times . . . \times d _ { n } ^ { * } } \mapsto M ^ { d _ { 1 } \times . . . \times d _ { n } ^ { * } } \mapsto M ^ { d _ { 1 } \times . . . \times d _ { n } ^ { * } } \mapsto M ^ { d _ { n } } .$ which permutes dimension $d _ { i }$ and $d _ { j }$ of a tensor $M \in \mathbb { R } ^ { d _ { 1 } \times . . . \times d _ { n } }$ . The Residual 4D Convolution Block can be formulated as:
+
+$$
+ { \mathcal { V } } _ { 3 D } =  { \mathcal { K } } _ { 3 D } + \varphi _ { ( U , C ) } \bigl (  { \mathcal { F } } _ { 4 D } \bigl ( \varphi _ { ( C , U ) } (  { \mathcal { X } } _ { 3 D } ) ;  { \mathcal { W } } _ { 4 D } \bigr ) \bigr )
+$$
+
+where $\mathcal { F } _ { 4 D } ( \mathcal { X } ; \mathcal { W } _ { 4 D } )$ is the introduced 4D convolution. $\mathcal { X } _ { 3 D }$ , $\mathcal { V } _ { 3 D } \in \mathbb { R } ^ { U \times C \times T \times H \times W }$ , and $U$ is merged into batch dimension so that $\mathcal { X } _ { 3 D }$ , $\mathcal { D } _ { 3 D }$ can be directly processed by standard 3D CNNs. Note that we employ $\varphi$ to permute the dimensions of $\mathcal { X } _ { 3 D }$ from $U \times C \times T \times H \times W$ to $C \times U \times T \times H \times W$ so that it can be processed by 4D convolutions. Then the output of 4D convolution is permuted reversely to 3D form so that the output dimensions are consistent with $\mathcal { X } _ { 3 D }$ . Batch Normalization (Ioffe & Szegedy, 2015) and ReLU activation (Nair & Hinton, 2010) are then applied. The detailed structure is described in Figure 1.
+
+Theoretically, any 3D CNN structure can be cast to 4D CNNs by integrating our 4D Convolutional Blocks. As shown in previous works (Zolfaghari et al., 2018; Xie et al., 2018; Wang et al., 2018b; Feichtenhofer et al., 2018), higher performance can be obtained by applying 2D convolutions at lower layers and 3D convolutions at higher layers of the 3D networks. In our framework, we utilize the ”Slow-path” introduced in Feichtenhofer et al. (2018) as our backbone, denoted as I3D-S. Although the original ”Slowpath” is designed for ResNet50, we can extend it to I3D-S ResNet18 for further experiments. The detailed structure of our 3D backbone is shown in Table 1.
+
+<table><tr><td rowspan=1 colspan=1>layer</td><td rowspan=1 colspan=3>I3D-S ResNet18</td><td rowspan=1 colspan=3>I3D-S ResNet50</td><td rowspan=1 colspan=1>output size</td></tr><tr><td rowspan=1 colspan=1>conV1</td><td rowspan=1 colspan=3>1×7×7,64, stride 1,2,2</td><td rowspan=1 colspan=3>1×7×7, 64, stride 1,2,2</td><td rowspan=1 colspan=1>4×112×112</td></tr><tr><td rowspan=1 colspan=1>res2</td><td rowspan=1 colspan=2>1×3×3,641×3×3,64</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1×1,641×3×3,641×1×1,256</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=1>4×56×56</td></tr><tr><td rowspan=1 colspan=1>res3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×3×3,1281×3×3,128</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1×1,1281×3×3,1281×1×1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=1>4×28×28</td></tr><tr><td rowspan=1 colspan=1>res4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×3×3,2563×3×3,256</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×1×1,2561×3×3,2561×1×1,1024</td><td rowspan=1 colspan=1>×6</td><td rowspan=1 colspan=1>4×14×14</td></tr><tr><td rowspan=1 colspan=1>res5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×3×3,5123×3×3,512</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×1×1,5121×3×3,5121×1×1,2048</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=1>4×7×7</td></tr></table>
+
+global average pool, fc $1 \times 1 \times 1$ Table 1: We use I3D-Slowpath from (Feichtenhofer et al., 2018) as our backbone. The output size of an example is shown in the right column, where the input has a size of $4 \times 2 2 4 \times 2 2 4$ . No temporal degenerating is performed in this structure.
+
+# 3.4 TRAINING AND INFERENCE
+
+Training. As shown in Figure 1, the convolutional part of the networks is composed of 3D convolution layers and the proposed Residual 4D Blocks. Each action unit is trained individually and in parallel in the 3D convolution layers, which share the same parameters. The 3D features computed from the action units are then fed to the Residual 4D Block, where the long-term temporal evolution of the consecutive action units can be modeled. Finally, global average pooling is computed on the sequence of all action units to form the final video-level representation.
+
+Inference. Given $U$ action units $\{ A _ { 1 } , A _ { 2 } , . . . , A _ { U } \}$ of a video, we denote $U _ { t r a i n }$ as the number of action units for training and $U _ { i n f e r }$ as the number of action units for inference. $U _ { t r a i n }$ and $U _ { i n f e r }$ are usually different because computation resource is limited in training, but high accuracy is encouraged in inference. We develop a new video-level inference method, which is described in Algorithm 1. The 3D convolutional layers are denote as $N _ { 3 D }$ , followed by the proposed 4D Blocks, $N _ { 4 D }$ .
+
+Algorithm 1: V4D Inference.   
+
+<table><tr><td>Networks</td><td>:The structure of networks is divided into two sub-networks by the first 4D Block, namely N3D and N4D.</td></tr><tr><td>Input</td><td>:Uinfer action units from a holistic video: {A1, A2,,AUin fer}.</td></tr><tr><td>Output</td><td>:The video-level prediction.</td></tr></table>
+
+# V4D Inference :
+
+1 $\{ A _ { 1 } , A _ { 2 } , . . . , A _ { U _ { i n f e r } } \}$ are fed into $N _ { 3 D }$ , generating intermediate feature maps for each unit {F1, F2, ..., FUinfer },Fi ∈ RC×T ×H×W ;
+
+2 For the $U _ { i n f e r }$ intermediate features, we equally divide them into $U _ { t r a i n }$ sections. Then we select one unit from each section $F _ { s e c _ { i } }$ and combine these $U _ { t r a i n }$ units into a video-level representations form a new set intermediate representation $F ^ { v i d e o } = ( F _ { s e c _ { 1 } } , F _ { s e c _ { 2 } } , . . . , F _ { s e c _ { U _ { t r a i n } } } )$ $\{ F _ { 1 } ^ { v i d e o } , F _ { 2 } ^ { v i d e o } , . . . , F _ { U _ { c o m b i n e d } } ^ { v i d e o } \} _ { } .$ in, where . These video-level Ucombined = (Uinf er/Utrain)Utrain , F videoi ∈ RUtrain×C×T ×H×W ;
+
+3 Each $F _ { i } ^ { v i d e o }$ in set $\{ F _ { 1 } ^ { v i d e o } , F _ { 2 } ^ { v i d e o } , . . . , F _ { U _ { c o m b i n e d } } ^ { v i d e o } \}$ are processed by $N _ { 4 D }$ to form a set of prediction scores, $\{ P _ { 1 } , P _ { 2 } , . . . , P _ { U _ { c o m b i n e d } } \}$ ;
+
+# 3.5 DISCUSSION
+
+We further demonstrate that the proposed V4D can be considered as a 4D generalization of a number of recent widely-applied methods, which may partially explain why our V4D works practically well on learning meaningful video-level representation.
+
+Temporal Segment Network. Our V4D is closely related to Temporal Segment Network (TSN). TSN was originally designed for 2D CNN, but it can be directly applied to 3D CNN to model video-level representation. TSN also employs a video-level sampling strategy with each action unit named “segment”. During training, each segment is calculated individually and the prediction scores after the fully-connected layer are then averaged. Since the fully-connected layer is a linear classifier, it is mathematically identical to calculating the average before the fully-connected layer (similar to our global average pooling) or after the fully-connected layer (similar to TSN). Thus our V4D can be considered as 3D $\mathrm { C N N + T S N }$ when all parameters in the 4D Blocks are set to 0.
+
+Dilated Temporal Convolution. One special form of 4D convolution kernel, $k \times 1 \times 1 \times 1$ , is closely related to Temporal Dilated Convolution (Lea et al., 2016). The input tensor $V$ can be considered as a $( C , U \times T , \bar { H } , W )$ tensor when all action units are concatenated along the temporal dimension. In this case, the $k \times 1 \times 1 \times 1$ 4D convolution can be considered as a dilated 3D convolution kernel of $k \times 1 \times 1$ with a dilation of $T$ frames. Note that the $k \times 1 \times 1 \times 1$ kernel is just the simplest form of our 4D convolutions, while our V4D architecture can utilize more complex kernels and thus can be more meaningful for learning stronger video representation. Furthermore, our 4D Blocks utilize residual connections, ensuring that both long-term and short-term representation can be learned jointly. Simply applying the dilated convolution might discard the short-term fine-grained features.
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS
+
+We conduct experiments on three standard benchmarks: Mini-Kinetics (Xie et al., 2018), Kinetics-400 (Carreira & Zisserman, 2017), and Something-Something-v1 (Goyal et al., 2017). Mini-kinetics dataset covers 200 action classes, and is a subset of Kinetics-400. Since some videos are no longer available for Kinetics dataset, our version of Kinetics-400 contains 240,436 and 19,796 videos in the training subset and validation subset, respectively. Our version of Mini-kinetics contains 78,422 videos for training, and 4,994 videos for validation. Each video has around 300 frames. SomethingSomething-v1 contains 108,499 videos totally, with 86,017 for training, 11,522 for validation, and 10,960 for testing. Each video has 36 to 72 frames.
+
+# 4.2 ABLATION STUDY ON MINI-KINETICS
+
+We use pre-trained weights from ImageNet to initialize the model. For training, we adapt the holistic sampling strategy mentioned in section 3.1. We uniformly divide the whole video into $U$ sections, and randomly select a clip of 32 frames from each section. For each clip, by following the sampling strategy in Feichtenhofer et al. (2018), we uniformly sample 4 frames with a fixed stride of 8 to form an action unit. We will study the impact of $U$ in the following experiments. We first resize each frame to $3 2 0 \times 2 5 6$ , and then randomly cropping is applied as Wang et al. (2018b). Then the cropped region is further resized to $2 2 4 \times 2 2 4$ . We utilize a SGD optimizer with an initial learning rate of 0.01, weight decay is set to $1 0 ^ { - 5 }$ with a momentum of 0.9. The learning rate drops by 10 at epoch 35, 60, 80, and the model is trained for 100 epochs in total.
+
+To make a fair comparison, we use spatial fully convolutional testing by following Wang et al. (2018b); Yue et al. (2018); Feichtenhofer et al. (2018). We sample 10 action units evenly from a full-length video, and crop $2 5 6 \times 2 5 6$ regions to spatially cover the whole frame for each action unit. Then we apply the proposed V4D inference. Note that, for the original TSN, 25 clips and 10-crop testing are used during inference. To make a fair comparison between I3D and our V4D, we instead apply this 10 clips and 3-crop inference strategy for TSN.
+
+Results. To verify the effectiveness of V4D, we compare it with the clip-based method I3D-S, and video-based method $\mathrm { T S N } { + } 3 \mathrm { D }$ CNN. To compensate the extra parameters introduced by 4D blocks, we add a $3 \times 3 \times 3$ residual block at res4 for I3D-S for a fair comparison, denoted as I3D-S ResNet1 $^ { 8 + + }$ . As shown in Table 2a, by using 4 times less frames than I3D-S during inference and with less parameters than I3D-S ResNet1 $^ { 8 + + }$ , V4D still obtain a $2 . 0 \%$ higher top-1 accuracy than I3D-S. Comparing with the state-of-the-art video-level method $\mathrm { T S N } { + } 3 \mathrm { D }$ CNN, V4D significantly outperforms it by $2 . 6 \%$ top-1 accuracy, with the same protocols used in training and inference.
+
+4D Convolution Kernels. As mentioned, our 4D convolution kernels can use 3 typical forms: $k \times 1 \times 1 \times 1$ , $k \times k \times 1 \times 1$ and $k \times k \times k \times k$ . In this experiment, we set $k = 3$ for simplicity, and apply a single 4D block at the end of res4 in I3D-S ResNet18. As shown in Table 2c, V4D with
+
+<table><tr><td>model</td><td>TtrainXUtrain</td><td>Tinfer XUinferX#crop</td><td>top-1</td><td>top5</td><td>parameters</td></tr><tr><td>I3D-S ResNet18</td><td>4×1</td><td>4×10×3</td><td>72.2</td><td>91.2</td><td>32.3M</td></tr><tr><td>I3D-S ResNet18</td><td>16×1</td><td>16 ×10×3</td><td>73.4</td><td>91.1</td><td>32.3M</td></tr><tr><td>I3D-S ResNet18++</td><td>16×1</td><td>16×10×3</td><td>73.6</td><td>91.5</td><td>34.1M</td></tr><tr><td>TSN+I3D-SResNet18</td><td>4×4</td><td>4×10×3</td><td>73.0</td><td>91.3</td><td>32.3M</td></tr><tr><td>V4DResNet18</td><td>4×4</td><td>4×10×3</td><td>75.6</td><td>92.7</td><td>33.1M</td></tr></table>
+
+(a) Effectiveness of V4D. $T$ represents temporal length of each action unit. $U$ represents the number of action units.
+
+<table><tr><td>model</td><td>input size</td><td>flops</td></tr><tr><td>I3D-SResNet18</td><td>16×256×256</td><td>55.1G</td></tr><tr><td>TSN+I3D-SResNet18</td><td>4×4×256× 256</td><td>55.1G</td></tr><tr><td>V4D ResNet18</td><td>4×4×256×256</td><td>58.8G</td></tr></table>
+
+(b) Forward flops of previous works and V4D. One 4D block at res3 and one at res4 for V4D.
+
+<table><tr><td>model</td><td>form of 4D kernel</td><td>top-1</td><td>top5</td></tr><tr><td>I3D-SResNet18 TSN+I3D-S ResNet18</td><td>- -</td><td>72.2 73.0</td><td>91.2 91.3</td></tr><tr><td>V4DResNet18</td><td>3×1×1×1</td><td>73.8</td><td>92.0</td></tr><tr><td>V4D ResNet18</td><td>3×3×1×1</td><td>74.5</td><td>92.4</td></tr><tr><td>V4D ResNet18</td><td>3×3×3×3</td><td>74.7</td><td>92.5</td></tr></table>
+
+(c) Different Forms of 4D Convolution Kernel.
+
+<table><tr><td>model</td><td>Utrain</td><td>top-1</td><td>top5</td></tr><tr><td>I3D-SResNet18</td><td>1</td><td>72.2</td><td>91.2</td></tr><tr><td>TSN+I3D-S ResNet18</td><td>4</td><td>73.0</td><td>91.3</td></tr><tr><td>V4DResNet18</td><td>3</td><td>74.3</td><td>92.2</td></tr><tr><td>V4D ResNet18</td><td>4</td><td>74.5</td><td>92.4</td></tr><tr><td>V4D ResNet18</td><td>5</td><td>74.5</td><td>92.3</td></tr><tr><td>V4D ResNet18</td><td>6</td><td>74.6</td><td>92.5</td></tr></table>
+
+<table><tr><td>model</td><td>4Dkernel</td><td>top-1</td><td>top5</td></tr><tr><td>I3D-SResNet18 TSN+I3D-SResNet18</td><td>-</td><td>72.2 73.0</td><td>91.2 91.3</td></tr><tr><td>V4DResNet18</td><td>= 1 at res3</td><td>74.2</td><td>92.3</td></tr><tr><td>V4D ResNet18</td><td>1 at res4</td><td>74.5</td><td>92.4</td></tr><tr><td>V4D ResNet18</td><td>1 at res5</td><td>73.6</td><td>91.4</td></tr><tr><td>V4D ResNet18</td><td></td><td></td><td></td></tr><tr><td></td><td>1 at res3,1 at res4</td><td>75.6</td><td>92.7</td></tr></table>
+
+(d) Position and Number of 4D Blocks. (e) Effect of $U _ { t r a i n }$ . Table 2: Ablations on Mini-Kinetics, with top-1 and top-5 classification accuracy $( \% )$ .
+
+$3 \times 3 \times 3 \times 3$ kernel can achieve the highest performance. However, by considering the trade-off between model parameters and performance, we use the kernel of $3 \times 3 \times 1 \times 1$ in the following experiments.
+
+On 4D Blocks. We evaluate the impact of position and number of 4D Blocks for our V4D. We investigate the performance of V4D by using one $3 \times 3 \times 1 \times 1$ 4D block at res3, res4 or res5. As shown in Table 2d, a higher accuracy can be obtained by applying the 4D block at res3 or res4, indicating that the merged long-short term features of the 4D block need to be further refined by 3D convolutions to generate more meaningful representation. Furthermore, inserting one 4D block at res3 and one at res4 can achieve a higher accuracy.
+
+Number of Action Units $U$ . We further evaluate our V4D by using different numbers of action units for training, with different values of hyperparameter $U$ . In this experiment, one $3 \times 3 \times 1 \times 1$ Residual 4D block is added at the end of res4 of ResNet18. As shown in Table 2e, $U$ does not have a significant impact to the performance, which suggests that: (1) V4D is a video-level feature learning model, and is robust against the number of short-term units; (2) an action generally does not contain many stages, and thus increasing $U$ is not helpful. In addition, increasing the number of action units means that the 4-th dimension is increased, requiring a larger 4D kernel to cover the long-range evolution of spatio-temporal representation.
+
+With state-of-the-art. We compare the results on Mini-Kinetics. 4D Residual Blocks are added into every other 3D residual blocks in res3 and res4. With much fewer frames utilized during training and inference, our V4D ResNet50 achieves a higher accuracy than all reported results, which is even higher than 3D ResNet101 having 5 compact Generalized Non-local Blocks. Note that our V4D ResNet18 can achieve a higher accuracy than 3D ResNet50, which further verify the effectiveness of our V4D structure.
+
+<table><tr><td>Model</td><td>Backbone</td><td>TtrainXUtrain</td><td>TinferXUinferX#crop</td><td>top-1</td><td>top5</td></tr><tr><td>S3D (Xie et al.,2018) I3D (Yue et al., 2018)</td><td>S3DInception 3DResNet50</td><td>64×1</td><td>N/A</td><td>78.9 75.5</td><td>-</td></tr><tr><td>I3D (Yue et al., 2018)</td><td>3D ResNet101</td><td>32×1</td><td>32×10×3</td><td>77.4</td><td>92.2</td></tr><tr><td>I3D+NL (Yue et al., 2018)</td><td></td><td>32×1</td><td>32 ×10×3</td><td></td><td>93.2</td></tr><tr><td></td><td>3D ResNet50</td><td>32×1</td><td>32×10×3</td><td>77.5</td><td>94.0</td></tr><tr><td>I3D+CGNL (Yue et al., 2018)</td><td>3DResNet50</td><td>32×1</td><td>32×10×3</td><td>78.8</td><td>94.4</td></tr><tr><td>I3D+NL (Yue et al.,2018)</td><td>3D ResNet101</td><td>32×1</td><td>32×10×3</td><td>79.2</td><td>93.2</td></tr><tr><td>I3D+CGNL (Yue et al.,2018)</td><td>3D ResNet101</td><td>32×1</td><td>32×10×3</td><td>79.9</td><td>93.4</td></tr><tr><td>V4D(Ours)</td><td>V4DResNet18</td><td>4×4</td><td>4×10×3</td><td>75.6</td><td>92.7</td></tr><tr><td>V4D(Ours)</td><td>V4D ResNet50</td><td>4×4</td><td>4×10×3</td><td>80.7</td><td>95.3</td></tr></table>
+
+Table 3: Results on Mini-Kinetics. $T$ - temporal length of action unit. $U$ - number of action units.
+
+# 4.3 RESULTS ON KINETICS
+
+We further conduct experiments on large-scale video recognition benchmark, Kinetics-400, to evaluate the capability of our V4D. To make a fair comparison, we utilize ResNet50 as backbone for V4D. The training and inference sampling strategy is identical to previous section, except that each action unit now contains 8 frames instead of 4. We set $U = 4$ so that there are $8 \times 4$ frames in total for training. Due to the limit of computation resource, we train the model in multiple stages. We first train the 3D ResNet50 backbone with 8-frame inputs. Then we load the 3D ResNet50 weights to V4D ResNet50, with all 4D Blocks fixed to zero. The V4D ResNet50 is then fine-tuned with $8 \times 4$ input frames. Finally, we optimize all 4D Blocks, and train the V4D with $8 \times 4$ frames. As shown in Table 4, our V4D achieves competitive results on Kinetics-400 benchmark.
+
+Table 4: Comparison with state-of-the-art on Kinetics.   
+
+<table><tr><td>Model</td><td>Backbone</td><td>top-1</td><td>top-5</td></tr><tr><td>ARTNet with TSN(Wang et al.,2018a)</td><td>ARTNetResNet18</td><td>70.7</td><td>89.3</td></tr><tr><td>ECO (Zolfaghari et al.,2018)</td><td>BN-Inception+3D ResNet18</td><td>70.0</td><td>89.4</td></tr><tr><td>S3D-G (Xie et al., 2018)</td><td>S3D Inception</td><td>74.7</td><td>93.4</td></tr><tr><td>Nonlocal Network(Wang et al.,2018a)</td><td>3DResNet50</td><td>76.5</td><td>92.6</td></tr><tr><td>SlowFast (Feichtenhofer et al.,2018)</td><td>SlowFast ResNet50</td><td>77.0</td><td>92.6</td></tr><tr><td>I3D(Carreira &amp; Zisserman,2017)</td><td>I3D Inception</td><td>72.1</td><td>90.3</td></tr><tr><td>Two-stream I3D(Carreira &amp; Zisserman,2017)</td><td>I3D Inception</td><td>75.7</td><td>92.0</td></tr><tr><td>I3D-S(Feichtenhofer et al., 2018)</td><td>Slow pathway ResNet50</td><td>74.9</td><td>91.5</td></tr><tr><td>V4D(Ours)</td><td>V4DResNet50</td><td>77.4</td><td>93.1</td></tr></table>
+
+# 4.4 RESULTS ON SOMETHING-SOMETHING-V1
+
+Something-Something dataset focuses on modeling temporal information and motion. The background is much cleaner than Kinetics but the motions of action categories are more complicated. Each video contains one single and continuous action with clear start and end on temporal dimension.
+
+<table><tr><td>Model</td><td>Backbone</td><td>top-1</td></tr><tr><td>MultiScale TRN (Zhou et al.,2018)</td><td>BN-Inception</td><td>34.4</td></tr><tr><td>ECO (Zolfaghari et al.,2018) S3D-G (Xie et al.,2018)</td><td>BN-Inception+3D ResNet18 S3D Inception</td><td>46.4 45.8</td></tr><tr><td>Nonlocal Network+GCN(Wang&amp; Gupta,2018)</td><td>3DResNet50</td><td>46.1</td></tr><tr><td>TrajectoryNet (Zhao et al.,2018)</td><td>S3D ResNet18</td><td>47.8</td></tr><tr><td>V4D(Ours)</td><td>V4DResNet50</td><td>50.4</td></tr></table>
+
+Table 5: Comparison with state-of-the-art on Something-Something-v1.
+
+Results. As shown in Table 4.4, our V4D achieves competitive results on the Something-Somethingv1. We use V4D ResNet50 pre-trained on Kinetics for experiments. Temporal Order. As shown in Xie et al. (2018), the performance can drop considerably by reversing the temporal order of short-term 3D features, suggesting that 3D CNNs can learn strong temporal order information. We further conduct experiments by reversing the frames within each action unit or reversing the sequence of action units, where the top-1 accuracy drops considerably by $5 0 . 4 \%  1 7 . 2 \%$ and $5 0 . 4 \% {  } 2 0 . 1 \%$ respectively, indicating that our V4D can capture both long-term and short-term temporal order.
+
+# 5 CONCLUSIONS
+
+We have introduced new Video-level 4D Convolutional Neural Networks, namely V4D, to learn strong temporal evolution of long-range spatio-temporal representation, as well as retaining 3D features with residual connections. In addition, we further introduce the training and inference methods for our V4D. Experiments were conducted on three video recognition benchmarks, where our V4D achieved the state-of-the-art results.
+
+# REFERENCES
+
+Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? A new model and the kinetics˜ dataset. In CVPR, 2017.
+
+Christopher Bongsoo Choy, JunYoung Gwak, and Silvio Savarese. 4d spatio-temporal convnets: Minkowski convolutional neural networks. CoRR, abs/1904.08755, 2019.
+
+Jeffrey Donahue, Lisa Anne Hendricks, Sergio Guadarrama, Marcus Rohrbach, Subhashini Venugopalan, Kate Saenko, and Trevor Darrell. Long-term recurrent convolutional networks for visual recognition and description. In CVPR, 2015.
+
+Alexey Dosovitskiy, Philipp Fischer, Eddy Ilg, Philip Hausser, Caner Hazirbas, Vladimir Golkov, ¨ Patrick van der Smagt, Daniel Cremers, and Thomas Brox. Flownet: Learning optical flow with convolutional networks. In ICCV, 2015.
+
+Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, and Kaiming He. Slowfast networks for video recognition. CoRR, abs/1812.03982, 2018.
+
+Raghav Goyal, Samira Ebrahimi Kahou, Vincent Michalski, Joanna Materzynska, Susanne Westphal, Heuna Kim, Valentin Haenel, Ingo Frund, Peter Yianilos, Moritz Mueller-Freitag, Florian Hoppe, ¨ Christian Thurau, Ingo Bax, and Roland Memisevic. The ”something something” video database for learning and evaluating visual common sense. In ICCV, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Fabian Caba Heilbron, Victor Escorcia, Bernard Ghanem, and Juan Carlos Niebles. Activitynet: A large-scale video benchmark for human activity understanding. In CVPR, 2015.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015.
+
+Shuiwang Ji, Wei Xu, Ming Yang, and Kai Yu. 3d convolutional neural networks for human action recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35:221–231, 2010.
+
+Ivan Laptev, Marcin Marszalek, Cordelia Schmid, and Benjamin Rozenfeld. Learning realistic human actions from movies. In CVPR, 2008.
+
+Colin Lea, Rene Vidal, Austin Reiter, and Gregory D. Hager. Temporal convolutional networks: A ´ unified approach to action segmentation. In ECCV Workshops, 2016.
+
+Xingyu Liu, Joon-Young Lee, and Hailin Jin. Learning video representations from correspondence proposals. CoRR, abs/1905.07853, 2019.
+
+Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010.
+
+Joe Yue-Hei Ng, Matthew Hausknecht, Sudheendra Vijayanarasimhan, Oriol Vinyals, Rajat Monga, and George Toderici. Beyond short snippets: Deep networks for video classification. In CVPR, 2015.
+
+A. J. Piergiovanni and Michael S. Ryoo. Representation flow for action recognition. CoRR, abs/1810.01455, 2018.
+
+Zhaofan Qiu, Ting Yao, and Tao Mei. Learning spatio-temporal representation with pseudo-3d residual networks. ICCV, 2017.
+
+Karen Simonyan and Andrew Zisserman. Two-stream convolutional networks for action recognition in videos. In NIPS, 2014.
+
+Shuyang Sun, Zhanghui Kuang, Lu Sheng, Wanli Ouyang, and Wei Zhang. Optical flow guided feature: A fast and robust motion representation for video action recognition. In CVPR, 2018.
+
+Du Tran, Lubomir D. Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. Learning spatiotemporal features with 3d convolutional networks. In ICCV, 2015.
+
+Limin Wang, Yuanjun Xiong, Zhe Wang, Yu Qiao, Dahua Lin, Xiaoou Tang, and Luc Van Gool. Temporal segment networks: Towards good practices for deep action recognition. In ECCV, 2016.
+
+Limin Wang, Wei Li, Wen Li, and Luc Van Gool. Appearance-and-relation networks for video classification. In CVPR, 2018a.   
+Xiaolong Wang and Abhinav Gupta. Videos as space-time region graphs. In ECCV, 2018.   
+Xiaolong Wang, Ross B. Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In CVPR, 2018b.   
+Saining Xie, Chen Sun, Jonathan Huang, Zhuowen Tu, and Kevin Murphy. Rethinking spatiotemporal feature learning: Speed-accuracy trade-offs in video classification. In ECCV, 2018.   
+Quanzeng You and Hao Jiang. Action4d: Real-time action recognition in the crowd and clutter. CoRR, abs/1806.02424, 2018.   
+Kaiyu Yue, Ming Sun, Yuchen Yuan, Feng Zhou, Errui Ding, and Fuxin Xu. Compact generalized non-local network. In NeurIPS, 2018.   
+Bowen Zhang, Limin Wang, Zhe Wang, Yu Qiao, and Hanli Wang. Real-time action recognition with enhanced motion vector CNNs. In CVPR, 2016.   
+Yue Zhao, Yuanjun Xiong, and Dahua Lin. Trajectory convolution for action recognition. In NeurIPS, 2018.   
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep \` features for discriminative localization. In CVPR, 2016.   
+Bolei Zhou, Alex Andonian, Aude Oliva, and Antonio Torralba. Temporal relational reasoning in videos. In ECCV, 2018.   
+Mohammadreza Zolfaghari, Kamaljeet Singh, and Thomas Brox. ECO: efficient convolutional network for online video understanding. In ECCV, 2018.
+
+# A APPENDIX
+
+# A.1 EXTENDED EXPERIMENTS ON LARGE-SCALE UNTRIMMED VIDEO RECOGNITION
+
+In order to check the generalization ability of our proposed V4D, we also conduct experiments for untrimmed video classification. To be specific, we choose ActivityNet v1.3 Heilbron et al. (2015), which is a large-scale untrimmed video dataset, containing videos of 5 to 10 minutes and typically large time lapses of the videos are not related with any activity of interest. We adopt V4D ResNet50 to compare with previous works. During inference, Multi-scale Temporal Window Integration is applied following (Wang et al., 2016). The evaluation metric is mean average precision (mAP) for action recognition. Note that only RGB modality is used as input.
+
+<table><tr><td>Model</td><td>Backbone</td><td>mAP</td></tr><tr><td>TSN Wang et al. (2016)</td><td>BN-Inception</td><td>79.7</td></tr><tr><td>TSN Wang et al. (2016)</td><td>Inception V3</td><td>83.3</td></tr><tr><td>TSN-Top3 Wang et al. (2016)</td><td>Inception V3</td><td>84.5</td></tr><tr><td>V4D(Ours)</td><td>V4DResNet50</td><td>88.9</td></tr></table>
+
+Table 6: Comparison with state-of-the-art on ActivityNet v1.3.
+
+# A.2 VISUALIZATION
+
+We implement 3D CAM based on Zhou et al. (2016), which was originally implemented for 2D cases. Generally, class activation maps (CAM) imply which areas are most important for classification. Here we show some random visualization results from validation set of Mini-Kinetics, where $\mathrm { T S N } +$ I3D-S ResNet18 generates wrong prediction while V4D ResNet18 generates correct prediction. The original RGB frames are shown in the first row. The second row shows the CAMs of $\mathrm { T S N } + \mathrm { I } 3 \mathrm { D } { \cdot } S$ ResNet18. The third row shows the CAMs of V4D ResNet18.
+
+![](images/b2eb9226b6c08b44a02458da613f06777ce22d63977096f440eedebef08eacc8.jpg)  
+Figure 3:
+
+![](images/53ae42551d104ef05eff94b8d3a163a7559328f1248efe0c0c4185de64c8f5c3.jpg)  
+Figure 4:
+
+![](images/aa212b08cf1798590b0acd37d54c446470023abcd2ab7feb69827194e66762ac.jpg)  
+Figure 5:
+
+![](images/3a38a00777c730b10613b13fc067539d468825908e6ecaba924e0a5fd3f3df73.jpg)  
+Figure 6:
+
+![](images/f4e2fca89d639fbc59d16a022dda0edf11da85ba63266482b5c1b96b4b90ccb3.jpg)  
+Figure 7:
+
+![](images/0674e833ebe4676da479b168290180165c76c3cc69e89bf87f8edf207744d224.jpg)  
+Figure 8:
+
+![](images/6799150db94b3ee2ade6b2373f4a1f40873e80ac59d22f5028fb1d64f6f4d347.jpg)  
+Figure 9:
+
+![](images/444886b16851fd0913576d274d56a89cb777632696959a7c3768cce7af508b66.jpg)  
+Figure 10:
+
+![](images/2224cb320bf5d5f4e6770f91a2829d414505899913a22c1d52acfc14425fdfc8.jpg)  
+Figure 11:
+
+![](images/fa7b3bd413f4829644ad58768d16c44e36b976fb2db97c90ce134a9476c58648.jpg)  
+Figure 12:
+
+![](images/e237ad16a83405351ce4e40de73b7fb84b335de365344481089b4cc7ebd413d4.jpg)  
+Figure 13:

parse/train/SJeLopEYDH/SJeLopEYDH_content_list.json

@@ -0,0 +1,1408 @@
+[
+    {
+        "type": "text",
+        "text": "V4D:4D CONVOLUTIONAL NEURAL NETWORKS FOR VIDEO-LEVEL REPRESENTATION LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shiwen Zhang, Sheng Guo, Weilin Huang∗ & Matthew R. Scott ",
+        "bbox": [
+            184,
+            170,
+            625,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Malong Technologies, Shenzhen, China Shenzhen Malong Artificial Intelligence Research Center, Shenzhen, China {shizhang,sheng,whuang,mscott}@malong.com ",
+        "bbox": [
+            184,
+            185,
+            676,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Limin Wang   \nState Key Laboratory for Novel Software Technology, Nanjing University, China   \nlmwang@nju.edu.cn ",
+        "bbox": [
+            184,
+            247,
+            714,
+            289
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            327,
+            544,
+            342
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most existing 3D CNNs for video representation learning are clip-based methods, and thus do not consider video-level temporal evolution of spatio-temporal features. In this paper, we propose Video-level 4D Convolutional Neural Networks, referred as V4D, to model the evolution of long-range spatio-temporal representation with 4D convolutions, and at the same time, to preserve strong 3D spatio-temporal representation with residual connections. Specifically, we design a new 4D residual block able to capture inter-clip interactions, which could enhance the representation power of the original clip-level 3D CNNs. The 4D residual blocks can be easily integrated into the existing 3D CNNs to perform long-range modeling hierarchically. We further introduce the training and inference methods for the proposed V4D. Extensive experiments are conducted on three video recognition benchmarks, where V4D achieves excellent results, surpassing recent 3D CNNs by a large margin. ",
+        "bbox": [
+            233,
+            358,
+            766,
+            525
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            554,
+            336,
+            570
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "3D convolutional neural networks (3D CNNs) and their variants (Ji et al., 2010; Tran et al., 2015; Carreira & Zisserman, 2017; Qiu et al., 2017; Wang et al., 2018b) provide a simple extension from 2D counterparts for video representation learning. However, due to practical issues such as memory consumption and computational cost, these models are mainly used for clip-level feature learning instead of learning from the whole video. The clip-based methods randomly sample a short clip (e.g., 32 frames) from a video for representation learning, and calculate prediction scores for each clip independently. The prediction scores of all clips are simply averaged to yield the video-level prediction. These clip-based models often ignore the video-level structure and long-range spatiotemporal dependency during training, as they only sample a small portion of the entire video. In fact, in some cases, it could be difficult to identify an action correctly by only using partial observation. Meanwhile, simply averaging the prediction scores of all clips could be sub-optimal during inference. To overcome this issue, Temporal Segment Network (TSN) (Wang et al., 2016) was proposed. TSN uniformly samples multiple clips from the entire video, and the average scores are used to guide back-propagation during training. Thus TSN is a video-level representation learning framework. However, the inter-clip interaction and video-level fusion in TSN is only performed at very late stage, which fails to capture finer temporal structures. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a general and flexible framework for video-level representation learning, called V4D. As shown in Figure 1, to model long-range dependency in a more efficient way, V4D is composed of two critical designs: (1) holistic sampling strategy, and (2) 4D convolutional interaction. We first introduce a video-level sampling strategy by uniformly sampling a sequence of short-term units covering the whole video. Then we model long-range spatio-temporal dependency by designing a unique 4D residual block. Specifically, we present a 4D convolutional operation to capture inter-clip interaction, which could enhance the representation power of the original clip-level 3D CNNs. The 4D residual blocks could be easily integrated into the existing 3D CNNs to perform long-range modeling hierarchically, which is more efficient than TSN. We also design a specific video-level inference algorithm for V4D. Finally, we verify the effectiveness of V4D on three video action recognition benchmarks, Mini-Kinetics (Xie et al., 2018), Kinetics-400 (Carreira & Zisserman, 2017) and Something-Something-V1 (Goyal et al., 2017). Our V4D achieves very competitive performance on the three benchmarks, and obtains evident performance improvement over its 3D counterparts. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            223,
+            354,
+            239
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Two-stream CNNs. Two-stream architecture was originally proposed by (Simonyan & Zisserman, 2014), where one stream is used for learning from RGB images, and the other one is applied to model optical flow. The results produced by the two streams are then fused at later stages, yielding the final prediction. Two-stream CNNs have achieved impressive results on various video recognition tasks. However, the main limitation is that the computation of optical flow is highly expensive where parallel optimization is difficult to implment, with significant resource explored. Recent effort has been devoted to reducing the computational cost on modeling optical flow, such as (Dosovitskiy et al., 2015; Sun et al., 2018; Piergiovanni & Ryoo, 2018; Zhang et al., 2016). The two-stream design is a general framework to boost the performance of various CNN models, which is orthogonal to the proposed V4D. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3D CNNs. Recently, 3D CNNs have been proposed (Tran et al., 2015; Carreira & Zisserman, 2017; Wang et al., 2018a;b; Feichtenhofer et al., 2018). By considering a video as a stack of frames, it is natural to develop 3D convolutions applied directly on video sequence. However, 3D CNNs often introduce a large number of model parameters, which inevitably require a large amount of training data to achieve good performance. As reported in (Wang et al., 2018b; Feichtenhofer et al., 2018), recent experimental results on large-scale benchmark, likes Kinetics-400 (Carreira & Zisserman, 2017), show that 3D CNNs can surpass their 2D counterparts in many cases,and even can be on par with or better than the two-stream 2D CNNs. It is noteworthy that most of 3D CNNs are clip-based methods, which only explore a certain part of the holistic video. ",
+        "bbox": [
+            174,
+            402,
+            825,
+            527
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Long-term Modeling Framework. Various long-term modeling frameworks have been developed for capturing more complex temporal structure for video-level representation learning. In (Laptev et al., 2008), video compositional models were proposed to jointly model local video events, where temporal pyramid matching was introduced with a bag-of-visual-words framework to compute longterm temporal structure. However, the rigid composition only works under defined constraints, e.g., prefixed duration and anchor points provided in time. A mainstream method is to process a continuous video sequence with recurrent neural networks $\\mathrm { N g }$ et al. (2015); Donahue et al. (2015), where 2D CNNs are used for frame-level feature extraction. Temporal Segment Network (TSN) (Wang et al., 2016) has been proposed to model video-level temporal information with a sparse sampling and aggregation strategy. TSN sparsely samples a set of frames from the whole video, and then the sampled frames are modelled by the same CNN backbone, which outputs a confident score for each frame. The output scores are averaged to generate final video-level prediction. TSN was originally designed for 2D CNNs, but it can be applied to 3D CNNs, which serves as one of the baselines in this paper. One of the main limitations of TSN is that it is difficult to model finer temporal structure due to the average aggregation. Temporal Relational Reasoning Network (TRN) (Zhou et al., 2018) was introduced to model temporal segment relation by encoding individual representation of each segment with relation networks. TRN is able to model video-level temporal order but lacks the capacity of capturing finer temporal structure. The proposed V4D can outperform these previous video-level learning methods on both appearance-dominated video recognition (e.g., on Kinetics) and motion-dominated video recognition (e.g., on Something-Something). It is able to model both short-term and long-term temporal structure with a unique design of 4D residual blocks. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            827
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 VIDEO-LEVEL 4D COVOLUTIONAL NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            848,
+            754,
+            864
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce new Video-level 4D Convolution Neural Networks, namely V4D, for video action recognition. This is the first attempt to design 4D convolutions for RGB-based video recognition. Previous methods, such as You & Jiang (2018); Choy et al. (2019), utilize 4D CNNs to process videos of point cloud by using 4D data as input. Instead, our V4D processes videos of RGB frames with input of 3D data. Existing 3D CNNs often take a short-term snippet as input, without considering the evolution of 3D spatio-temporal features for video-level representation. In Wang et al. (2018b); Yue et al. (2018); Liu et al. (2019), self-attention mechanism was developed to model non-local spatio-temporal features, but these methods were originally designed for clip-based 3D CNNs. It remains unclear how to incorporate such operations on holistic video representation, and whether such operations are useful for video-level representation learning. Our goal is to model 3D spatio-temporal features globally, which can be implemented in a higher dimension. In this work, we introduce new Residual 4D Blocks, which allow us to cast 3D CNNs into 4D CNNs for learning long-range interactions of the 3D features, resulting in a “time of time” video-level representation. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa8425da7f07f6416ac6b0c97065c8f4e1bd6975e14cc1333aeafa20d3b3241e.jpg",
+        "image_caption": [
+            "Figure 1: Video-level 4D Convolutional Neural Networks for video recognition. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            102,
+            790,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            276,
+            825,
+            416
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 A VIDEO-LEVEL SAMPLING STRATEGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            435,
+            478,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To model meaningful video-level representation for action recognition, the input to the networks has to cover the holistic duration of a given video, and at the same time preserve short-term action details. A straightforward approach is to implement per-frame training of the networks yet this is not practical by considering the limit of computation resource. In this work, we uniformly divide the whole video into $U$ sections, and select a snippet from each section to represent a short-term action pattern, called “action unit”. Then we have $U$ action units to represent the holistic action in a video. Formally, we denote the video-level input $V = \\{ A _ { 1 } , A _ { 2 } , . . . , \\tilde { A _ { U } } \\}$ , where $A _ { i } \\in \\mathbb { R } ^ { C \\times T \\times H \\times W }$ . During training, each action unit $A _ { i }$ is randomly selected from each of the $U$ sections. During testing, the center of each $A _ { i }$ locates exactly at the center of the corresponding section. ",
+        "bbox": [
+            173,
+            460,
+            826,
+            587
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 4D CONVOLUTIONS FOR LEARNING SPATIO-TEMPORAL INTERACTION ",
+        "text_level": 1,
+        "bbox": [
+            191,
+            604,
+            691,
+            618
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3D Convolutional kernels have been proposed, and are powerful to model short-term spatio-temporal features. However, the receptive fields of 3D kernels are often limited due to the small sizes of kernels, and pooling operations are applied to enlarge the receptive fields, resulting in a significant cost of information loss. This inspired us to develop new operations which are able to model both short- and long-term spatio-temporal representations simultaneously, with easy implementations and fast training. From this prospective, we propose 4D convolutions for better modeling the long-range spatio-temporal interactions. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            728
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we denote the input to 4D convolutions as a tensor $V$ of size $( C , U , T , H , W )$ , where $C$ is number of channel, $U$ is the number of action units (the 4-th dimension in this paper), $T , H , W$ are temporal length, height and width of an action unit. We omit the batch dimension for simplicity. By following the annotations provided in Ji et al. (2010), a pixel at position $( u , t , h , w )$ of the $j$ th channel in the output is denoted as $o _ { j } ^ { u t h w }$ , and a 4D convolution operation can be formulated as : ",
+        "bbox": [
+            174,
+            734,
+            825,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2386215137c1ec660e38445f8d0f2e8f495558ff964513d916f093680f1a325b.jpg",
+        "text": "$$\no _ { j } ^ { u t h w } = b _ { j } + \\sum _ { c } ^ { C _ { i n } } \\sum _ { s = 0 } ^ { S - 1 } \\sum _ { p = 0 } ^ { P - 1 } \\sum _ { q = 0 } ^ { Q - 1 } \\sum _ { r = 0 } ^ { R - 1 } \\mathcal { W } _ { j c } ^ { s p q r } v _ { c } ^ { ( u + s ) ( t + p ) ( h + q ) ( w + r ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            815,
+            714,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $S \\times P \\times Q \\times R$ $b _ { j }$ is a bias term, in is the shape of 4D convolutional kernel, is one of the $C _ { i n }$ input channels of the feature maps from input $\\mathcal { W } _ { j c } ^ { s p q r }$ is the weight at the position $( s , p , q , r )$ $V$ , of the kernel, corresponding to the $c$ -th channel of the input feature maps and $j$ -th channel of the output feature maps. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/732309d3a94b05e6a4a3e5041b903bcf639a21cff162c6af86bbfd04d3b626d8.jpg",
+        "image_caption": [
+            "Figure 2: Implementation of 4D kernels, compared to3D kernel s. $U$ denotes the number of action units, with shape of $T , H , W$ . Channel and batch dimensions are omitted for clarity. The kernels are colored in Blue, with the center of each kernel colored in Green. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            331,
+            101,
+            660,
+            184
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Convolutional operation is linear, and the sequential sum operations in E.q. 1 are exchangeable. Thus we can generate E.q. 2, where the expression in the parentheses can be implemented by 3D convolutions, allowing us to implement 4D convolutions using 3D convolutions, while most deep learning libraries do not directly provide 4D convolutional operations. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            314
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d58107b3f68f20388bc5e795fb0d379816a97bb8655c926956740138c8a20b6.jpg",
+        "text": "$$\no _ { j } ^ { u t h w } = b _ { j } + \\sum _ { s = 0 } ^ { S - 1 } ( \\sum _ { c } \\sum _ { p = 0 } ^ { C _ { i n } } \\sum _ { q = 0 } ^ { Q - 1 } \\sum _ { r = 0 } ^ { R - 1 } \\mathcal { W } _ { j c } ^ { s p q r } v _ { c } ^ { ( u + s ) ( t + p ) ( h + q ) ( w + r ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            334,
+            718,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "With the 4D convolutional kernel, the short-term 3D features of an individual action unit and longterm temporal evolution of multiple action units can be modeled simultaneously in the 4D space. Compared to 3D convolutions, the proposed 4D convolutions are able to model videos in a more meaningful 4D feature space that enables it to learn more complicated interactions of long-range 3D spatio-temporal representation. However, 4D convolutions inevitably introduce more parameters and computation cost. For example, a 4D convolutional kernel of $k \\times k \\times k \\times k$ employs $k$ times more parameters than a 3D kernel of $k \\times k \\times k$ . In practice, we explore $k \\times k \\times 1 \\times 1$ and $k \\times 1 \\times 1 \\times 1$ kernels, to reduce the parameters and avoid the risk of overfitting. The implementation of different kernels is shown in Figure 2. ",
+        "bbox": [
+            173,
+            393,
+            826,
+            520
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 VIDEO-LEVEL 4D CNN ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            495,
+            555
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate that our 4D convolutions can be integrated into existing CNN architecture for action recognition. To fully utilize current state-of-the-art 3D CNNs, we propose a new Residual 4D Convolution Block, by designing a 4D convolution in the residual structure introduced in (He et al., 2016). This allows it to aggregate both short-term 3D features and long-term evolution of the spatio-temporal representations for video-level action recognition. Specifically, we define a permutation function $\\varphi _ { ( d _ { i } , d _ { j } ) } : M ^ { d _ { 1 } \\times . . . \\times d _ { i } \\times . . . \\times d _ { j } \\times . . . \\times d _ { n } } \\mapsto M ^ { d _ { 1 } \\Breve { \\times } . . . \\times d _ { j } \\times . . . \\hslash d _ { i } \\times . . . \\times d _ { n } ^ { * } } \\mapsto M ^ { d _ { 1 } \\times . . . \\times d _ { n } ^ { * } } \\mapsto M ^ { d _ { 1 } \\times . . . \\times d _ { n } ^ { * } } \\mapsto M ^ { d _ { n } } .$ which permutes dimension $d _ { i }$ and $d _ { j }$ of a tensor $M \\in \\mathbb { R } ^ { d _ { 1 } \\times . . . \\times d _ { n } }$ . The Residual 4D Convolution Block can be formulated as: ",
+        "bbox": [
+            173,
+            568,
+            826,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/37b1eb5ad5e7237de518b27c5a62f7fbede8cc54931187abe14f25cf7c734f73.jpg",
+        "text": "$$\n { \\mathcal { V } } _ { 3 D } =  { \\mathcal { K } } _ { 3 D } + \\varphi _ { ( U , C ) } \\bigl (  { \\mathcal { F } } _ { 4 D } \\bigl ( \\varphi _ { ( C , U ) } (  { \\mathcal { X } } _ { 3 D } ) ;  { \\mathcal { W } } _ { 4 D } \\bigr ) \\bigr )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            693,
+            666,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { F } _ { 4 D } ( \\mathcal { X } ; \\mathcal { W } _ { 4 D } )$ is the introduced 4D convolution. $\\mathcal { X } _ { 3 D }$ , $\\mathcal { V } _ { 3 D } \\in \\mathbb { R } ^ { U \\times C \\times T \\times H \\times W }$ , and $U$ is merged into batch dimension so that $\\mathcal { X } _ { 3 D }$ , $\\mathcal { D } _ { 3 D }$ can be directly processed by standard 3D CNNs. Note that we employ $\\varphi$ to permute the dimensions of $\\mathcal { X } _ { 3 D }$ from $U \\times C \\times T \\times H \\times W$ to $C \\times U \\times T \\times H \\times W$ so that it can be processed by 4D convolutions. Then the output of 4D convolution is permuted reversely to 3D form so that the output dimensions are consistent with $\\mathcal { X } _ { 3 D }$ . Batch Normalization (Ioffe & Szegedy, 2015) and ReLU activation (Nair & Hinton, 2010) are then applied. The detailed structure is described in Figure 1. ",
+        "bbox": [
+            173,
+            719,
+            825,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theoretically, any 3D CNN structure can be cast to 4D CNNs by integrating our 4D Convolutional Blocks. As shown in previous works (Zolfaghari et al., 2018; Xie et al., 2018; Wang et al., 2018b; Feichtenhofer et al., 2018), higher performance can be obtained by applying 2D convolutions at lower layers and 3D convolutions at higher layers of the 3D networks. In our framework, we utilize the ”Slow-path” introduced in Feichtenhofer et al. (2018) as our backbone, denoted as I3D-S. Although the original ”Slowpath” is designed for ResNet50, we can extend it to I3D-S ResNet18 for further experiments. The detailed structure of our 3D backbone is shown in Table 1. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/989d2b903e11af3d026f91038f110c4d4e35ea3b4683271b4b2b2e79b14e169f.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "global average pool, fc $1 \\times 1 \\times 1$ Table 1: We use I3D-Slowpath from (Feichtenhofer et al., 2018) as our backbone. The output size of an example is shown in the right column, where the input has a size of $4 \\times 2 2 4 \\times 2 2 4$ . No temporal degenerating is performed in this structure. "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>layer</td><td rowspan=1 colspan=3>I3D-S ResNet18</td><td rowspan=1 colspan=3>I3D-S ResNet50</td><td rowspan=1 colspan=1>output size</td></tr><tr><td rowspan=1 colspan=1>conV1</td><td rowspan=1 colspan=3>1×7×7,64, stride 1,2,2</td><td rowspan=1 colspan=3>1×7×7, 64, stride 1,2,2</td><td rowspan=1 colspan=1>4×112×112</td></tr><tr><td rowspan=1 colspan=1>res2</td><td rowspan=1 colspan=2>1×3×3,641×3×3,64</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1×1,641×3×3,641×1×1,256</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=1>4×56×56</td></tr><tr><td rowspan=1 colspan=1>res3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×3×3,1281×3×3,128</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>1×1×1,1281×3×3,1281×1×1,512</td><td rowspan=1 colspan=1>×4</td><td rowspan=1 colspan=1>4×28×28</td></tr><tr><td rowspan=1 colspan=1>res4</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×3×3,2563×3×3,256</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×1×1,2561×3×3,2561×1×1,1024</td><td rowspan=1 colspan=1>×6</td><td rowspan=1 colspan=1>4×14×14</td></tr><tr><td rowspan=1 colspan=1>res5</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×3×3,5123×3×3,512</td><td rowspan=1 colspan=1>×2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>3×1×1,5121×3×3,5121×1×1,2048</td><td rowspan=1 colspan=1>×3</td><td rowspan=1 colspan=1>4×7×7</td></tr></table>",
+        "bbox": [
+            210,
+            99,
+            792,
+            270
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 TRAINING AND INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            335,
+            405,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training. As shown in Figure 1, the convolutional part of the networks is composed of 3D convolution layers and the proposed Residual 4D Blocks. Each action unit is trained individually and in parallel in the 3D convolution layers, which share the same parameters. The 3D features computed from the action units are then fed to the Residual 4D Block, where the long-term temporal evolution of the consecutive action units can be modeled. Finally, global average pooling is computed on the sequence of all action units to form the final video-level representation. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Inference. Given $U$ action units $\\{ A _ { 1 } , A _ { 2 } , . . . , A _ { U } \\}$ of a video, we denote $U _ { t r a i n }$ as the number of action units for training and $U _ { i n f e r }$ as the number of action units for inference. $U _ { t r a i n }$ and $U _ { i n f e r }$ are usually different because computation resource is limited in training, but high accuracy is encouraged in inference. We develop a new video-level inference method, which is described in Algorithm 1. The 3D convolutional layers are denote as $N _ { 3 D }$ , followed by the proposed 4D Blocks, $N _ { 4 D }$ . ",
+        "bbox": [
+            173,
+            450,
+            825,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/275737e28526167aced06f7d1bba18e37a7488a64278d1c8359efa565d285c41.jpg",
+        "table_caption": [
+            "Algorithm 1: V4D Inference. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Networks</td><td>:The structure of networks is divided into two sub-networks by the first 4D Block, namely N3D and N4D.</td></tr><tr><td>Input</td><td>:Uinfer action units from a holistic video: {A1, A2,,AUin fer}.</td></tr><tr><td>Output</td><td>:The video-level prediction.</td></tr></table>",
+        "bbox": [
+            173,
+            558,
+            772,
+            614
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "V4D Inference : ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            619,
+            285,
+            632
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1 $\\{ A _ { 1 } , A _ { 2 } , . . . , A _ { U _ { i n f e r } } \\}$ are fed into $N _ { 3 D }$ , generating intermediate feature maps for each unit {F1, F2, ..., FUinfer },Fi ∈ RC×T ×H×W ; ",
+        "bbox": [
+            163,
+            633,
+            772,
+            665
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2 For the $U _ { i n f e r }$ intermediate features, we equally divide them into $U _ { t r a i n }$ sections. Then we select one unit from each section $F _ { s e c _ { i } }$ and combine these $U _ { t r a i n }$ units into a video-level representations form a new set intermediate representation $F ^ { v i d e o } = ( F _ { s e c _ { 1 } } , F _ { s e c _ { 2 } } , . . . , F _ { s e c _ { U _ { t r a i n } } } )$ $\\{ F _ { 1 } ^ { v i d e o } , F _ { 2 } ^ { v i d e o } , . . . , F _ { U _ { c o m b i n e d } } ^ { v i d e o } \\} _ { } .$ in, where . These video-level Ucombined = (Uinf er/Utrain)Utrain , F videoi ∈ RUtrain×C×T ×H×W ; ",
+        "bbox": [
+            160,
+            666,
+            772,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Each $F _ { i } ^ { v i d e o }$ in set $\\{ F _ { 1 } ^ { v i d e o } , F _ { 2 } ^ { v i d e o } , . . . , F _ { U _ { c o m b i n e d } } ^ { v i d e o } \\}$ are processed by $N _ { 4 D }$ to form a set of prediction scores, $\\{ P _ { 1 } , P _ { 2 } , . . . , P _ { U _ { c o m b i n e d } } \\}$ ; ",
+        "bbox": [
+            161,
+            742,
+            764,
+            773
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            820,
+            302,
+            834
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We further demonstrate that the proposed V4D can be considered as a 4D generalization of a number of recent widely-applied methods, which may partially explain why our V4D works practically well on learning meaningful video-level representation. ",
+        "bbox": [
+            174,
+            847,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Temporal Segment Network. Our V4D is closely related to Temporal Segment Network (TSN). TSN was originally designed for 2D CNN, but it can be directly applied to 3D CNN to model video-level representation. TSN also employs a video-level sampling strategy with each action unit named “segment”. During training, each segment is calculated individually and the prediction scores after the fully-connected layer are then averaged. Since the fully-connected layer is a linear classifier, it is mathematically identical to calculating the average before the fully-connected layer (similar to our global average pooling) or after the fully-connected layer (similar to TSN). Thus our V4D can be considered as 3D $\\mathrm { C N N + T S N }$ when all parameters in the 4D Blocks are set to 0. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dilated Temporal Convolution. One special form of 4D convolution kernel, $k \\times 1 \\times 1 \\times 1$ , is closely related to Temporal Dilated Convolution (Lea et al., 2016). The input tensor $V$ can be considered as a $( C , U \\times T , \\bar { H } , W )$ tensor when all action units are concatenated along the temporal dimension. In this case, the $k \\times 1 \\times 1 \\times 1$ 4D convolution can be considered as a dilated 3D convolution kernel of $k \\times 1 \\times 1$ with a dilation of $T$ frames. Note that the $k \\times 1 \\times 1 \\times 1$ kernel is just the simplest form of our 4D convolutions, while our V4D architecture can utilize more complex kernels and thus can be more meaningful for learning stronger video representation. Furthermore, our 4D Blocks utilize residual connections, ensuring that both long-term and short-term representation can be learned jointly. Simply applying the dilated convolution might discard the short-term fine-grained features. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            319
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            340,
+            326,
+            357
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            372,
+            287,
+            387
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on three standard benchmarks: Mini-Kinetics (Xie et al., 2018), Kinetics-400 (Carreira & Zisserman, 2017), and Something-Something-v1 (Goyal et al., 2017). Mini-kinetics dataset covers 200 action classes, and is a subset of Kinetics-400. Since some videos are no longer available for Kinetics dataset, our version of Kinetics-400 contains 240,436 and 19,796 videos in the training subset and validation subset, respectively. Our version of Mini-kinetics contains 78,422 videos for training, and 4,994 videos for validation. Each video has around 300 frames. SomethingSomething-v1 contains 108,499 videos totally, with 86,017 for training, 11,522 for validation, and 10,960 for testing. Each video has 36 to 72 frames. ",
+        "bbox": [
+            174,
+            398,
+            826,
+            510
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ABLATION STUDY ON MINI-KINETICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            478,
+            542
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use pre-trained weights from ImageNet to initialize the model. For training, we adapt the holistic sampling strategy mentioned in section 3.1. We uniformly divide the whole video into $U$ sections, and randomly select a clip of 32 frames from each section. For each clip, by following the sampling strategy in Feichtenhofer et al. (2018), we uniformly sample 4 frames with a fixed stride of 8 to form an action unit. We will study the impact of $U$ in the following experiments. We first resize each frame to $3 2 0 \\times 2 5 6$ , and then randomly cropping is applied as Wang et al. (2018b). Then the cropped region is further resized to $2 2 4 \\times 2 2 4$ . We utilize a SGD optimizer with an initial learning rate of 0.01, weight decay is set to $1 0 ^ { - 5 }$ with a momentum of 0.9. The learning rate drops by 10 at epoch 35, 60, 80, and the model is trained for 100 epochs in total. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            680
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To make a fair comparison, we use spatial fully convolutional testing by following Wang et al. (2018b); Yue et al. (2018); Feichtenhofer et al. (2018). We sample 10 action units evenly from a full-length video, and crop $2 5 6 \\times 2 5 6$ regions to spatially cover the whole frame for each action unit. Then we apply the proposed V4D inference. Note that, for the original TSN, 25 clips and 10-crop testing are used during inference. To make a fair comparison between I3D and our V4D, we instead apply this 10 clips and 3-crop inference strategy for TSN. ",
+        "bbox": [
+            174,
+            686,
+            825,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results. To verify the effectiveness of V4D, we compare it with the clip-based method I3D-S, and video-based method $\\mathrm { T S N } { + } 3 \\mathrm { D }$ CNN. To compensate the extra parameters introduced by 4D blocks, we add a $3 \\times 3 \\times 3$ residual block at res4 for I3D-S for a fair comparison, denoted as I3D-S ResNet1 $^ { 8 + + }$ . As shown in Table 2a, by using 4 times less frames than I3D-S during inference and with less parameters than I3D-S ResNet1 $^ { 8 + + }$ , V4D still obtain a $2 . 0 \\%$ higher top-1 accuracy than I3D-S. Comparing with the state-of-the-art video-level method $\\mathrm { T S N } { + } 3 \\mathrm { D }$ CNN, V4D significantly outperforms it by $2 . 6 \\%$ top-1 accuracy, with the same protocols used in training and inference. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4D Convolution Kernels. As mentioned, our 4D convolution kernels can use 3 typical forms: $k \\times 1 \\times 1 \\times 1$ , $k \\times k \\times 1 \\times 1$ and $k \\times k \\times k \\times k$ . In this experiment, we set $k = 3$ for simplicity, and apply a single 4D block at the end of res4 in I3D-S ResNet18. As shown in Table 2c, V4D with ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/d17a54dd14f3a67a1332023efcf5143b5c6e91f65c5753ec8b840ddfc008a8a9.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(a) Effectiveness of V4D. $T$ represents temporal length of each action unit. $U$ represents the number of action units. "
+        ],
+        "table_body": "<table><tr><td>model</td><td>TtrainXUtrain</td><td>Tinfer XUinferX#crop</td><td>top-1</td><td>top5</td><td>parameters</td></tr><tr><td>I3D-S ResNet18</td><td>4×1</td><td>4×10×3</td><td>72.2</td><td>91.2</td><td>32.3M</td></tr><tr><td>I3D-S ResNet18</td><td>16×1</td><td>16 ×10×3</td><td>73.4</td><td>91.1</td><td>32.3M</td></tr><tr><td>I3D-S ResNet18++</td><td>16×1</td><td>16×10×3</td><td>73.6</td><td>91.5</td><td>34.1M</td></tr><tr><td>TSN+I3D-SResNet18</td><td>4×4</td><td>4×10×3</td><td>73.0</td><td>91.3</td><td>32.3M</td></tr><tr><td>V4DResNet18</td><td>4×4</td><td>4×10×3</td><td>75.6</td><td>92.7</td><td>33.1M</td></tr></table>",
+        "bbox": [
+            230,
+            101,
+            769,
+            165
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/9a125f06fdb275709b5ee3fa9bc8dae6cc267938179236a5230ce8d82076637c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>input size</td><td>flops</td></tr><tr><td>I3D-SResNet18</td><td>16×256×256</td><td>55.1G</td></tr><tr><td>TSN+I3D-SResNet18</td><td>4×4×256× 256</td><td>55.1G</td></tr><tr><td>V4D ResNet18</td><td>4×4×256×256</td><td>58.8G</td></tr></table>",
+        "bbox": [
+            194,
+            218,
+            490,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(b) Forward flops of previous works and V4D. One 4D block at res3 and one at res4 for V4D. ",
+        "bbox": [
+            192,
+            265,
+            491,
+            290
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/ba8210b66e660697a025d1e67fe31175e030b2faa82ee73cd1420b1e481b7861.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(c) Different Forms of 4D Convolution Kernel. "
+        ],
+        "table_body": "<table><tr><td>model</td><td>form of 4D kernel</td><td>top-1</td><td>top5</td></tr><tr><td>I3D-SResNet18 TSN+I3D-S ResNet18</td><td>- -</td><td>72.2 73.0</td><td>91.2 91.3</td></tr><tr><td>V4DResNet18</td><td>3×1×1×1</td><td>73.8</td><td>92.0</td></tr><tr><td>V4D ResNet18</td><td>3×3×1×1</td><td>74.5</td><td>92.4</td></tr><tr><td>V4D ResNet18</td><td>3×3×3×3</td><td>74.7</td><td>92.5</td></tr></table>",
+        "bbox": [
+            493,
+            207,
+            803,
+            272
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a12838f0c821da3c461e0194d4e84d148e6729ab568c50cc8d10fb6823f3f4bd.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>model</td><td>Utrain</td><td>top-1</td><td>top5</td></tr><tr><td>I3D-SResNet18</td><td>1</td><td>72.2</td><td>91.2</td></tr><tr><td>TSN+I3D-S ResNet18</td><td>4</td><td>73.0</td><td>91.3</td></tr><tr><td>V4DResNet18</td><td>3</td><td>74.3</td><td>92.2</td></tr><tr><td>V4D ResNet18</td><td>4</td><td>74.5</td><td>92.4</td></tr><tr><td>V4D ResNet18</td><td>5</td><td>74.5</td><td>92.3</td></tr><tr><td>V4D ResNet18</td><td>6</td><td>74.6</td><td>92.5</td></tr></table>",
+        "bbox": [
+            522,
+            304,
+            792,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/77373849af1006ccc6dcab91fc9c784e7ac513660134c5ed1c11b2bbaef84897.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(d) Position and Number of 4D Blocks. (e) Effect of $U _ { t r a i n }$ . Table 2: Ablations on Mini-Kinetics, with top-1 and top-5 classification accuracy $( \\% )$ . "
+        ],
+        "table_body": "<table><tr><td>model</td><td>4Dkernel</td><td>top-1</td><td>top5</td></tr><tr><td>I3D-SResNet18 TSN+I3D-SResNet18</td><td>-</td><td>72.2 73.0</td><td>91.2 91.3</td></tr><tr><td>V4DResNet18</td><td>= 1 at res3</td><td>74.2</td><td>92.3</td></tr><tr><td>V4D ResNet18</td><td>1 at res4</td><td>74.5</td><td>92.4</td></tr><tr><td>V4D ResNet18</td><td>1 at res5</td><td>73.6</td><td>91.4</td></tr><tr><td>V4D ResNet18</td><td></td><td></td><td></td></tr><tr><td></td><td>1 at res3,1 at res4</td><td>75.6</td><td>92.7</td></tr></table>",
+        "bbox": [
+            192,
+            303,
+            506,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "$3 \\times 3 \\times 3 \\times 3$ kernel can achieve the highest performance. However, by considering the trade-off between model parameters and performance, we use the kernel of $3 \\times 3 \\times 1 \\times 1$ in the following experiments. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            474
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On 4D Blocks. We evaluate the impact of position and number of 4D Blocks for our V4D. We investigate the performance of V4D by using one $3 \\times 3 \\times 1 \\times 1$ 4D block at res3, res4 or res5. As shown in Table 2d, a higher accuracy can be obtained by applying the 4D block at res3 or res4, indicating that the merged long-short term features of the 4D block need to be further refined by 3D convolutions to generate more meaningful representation. Furthermore, inserting one 4D block at res3 and one at res4 can achieve a higher accuracy. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            566
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Number of Action Units $U$ . We further evaluate our V4D by using different numbers of action units for training, with different values of hyperparameter $U$ . In this experiment, one $3 \\times 3 \\times 1 \\times 1$ Residual 4D block is added at the end of res4 of ResNet18. As shown in Table 2e, $U$ does not have a significant impact to the performance, which suggests that: (1) V4D is a video-level feature learning model, and is robust against the number of short-term units; (2) an action generally does not contain many stages, and thus increasing $U$ is not helpful. In addition, increasing the number of action units means that the 4-th dimension is increased, requiring a larger 4D kernel to cover the long-range evolution of spatio-temporal representation. ",
+        "bbox": [
+            173,
+            573,
+            825,
+            684
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "With state-of-the-art. We compare the results on Mini-Kinetics. 4D Residual Blocks are added into every other 3D residual blocks in res3 and res4. With much fewer frames utilized during training and inference, our V4D ResNet50 achieves a higher accuracy than all reported results, which is even higher than 3D ResNet101 having 5 compact Generalized Non-local Blocks. Note that our V4D ResNet18 can achieve a higher accuracy than 3D ResNet50, which further verify the effectiveness of our V4D structure. ",
+        "bbox": [
+            173,
+            690,
+            825,
+            773
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/aa637c0d1a58179999c2ad0799c6c1b5efca64122bc3a0aef6f0d204f539ec79.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Results on Mini-Kinetics. $T$ - temporal length of action unit. $U$ - number of action units. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Backbone</td><td>TtrainXUtrain</td><td>TinferXUinferX#crop</td><td>top-1</td><td>top5</td></tr><tr><td>S3D (Xie et al.,2018) I3D (Yue et al., 2018)</td><td>S3DInception 3DResNet50</td><td>64×1</td><td>N/A</td><td>78.9 75.5</td><td>-</td></tr><tr><td>I3D (Yue et al., 2018)</td><td>3D ResNet101</td><td>32×1</td><td>32×10×3</td><td>77.4</td><td>92.2</td></tr><tr><td>I3D+NL (Yue et al., 2018)</td><td></td><td>32×1</td><td>32 ×10×3</td><td></td><td>93.2</td></tr><tr><td></td><td>3D ResNet50</td><td>32×1</td><td>32×10×3</td><td>77.5</td><td>94.0</td></tr><tr><td>I3D+CGNL (Yue et al., 2018)</td><td>3DResNet50</td><td>32×1</td><td>32×10×3</td><td>78.8</td><td>94.4</td></tr><tr><td>I3D+NL (Yue et al.,2018)</td><td>3D ResNet101</td><td>32×1</td><td>32×10×3</td><td>79.2</td><td>93.2</td></tr><tr><td>I3D+CGNL (Yue et al.,2018)</td><td>3D ResNet101</td><td>32×1</td><td>32×10×3</td><td>79.9</td><td>93.4</td></tr><tr><td>V4D(Ours)</td><td>V4DResNet18</td><td>4×4</td><td>4×10×3</td><td>75.6</td><td>92.7</td></tr><tr><td>V4D(Ours)</td><td>V4D ResNet50</td><td>4×4</td><td>4×10×3</td><td>80.7</td><td>95.3</td></tr></table>",
+        "bbox": [
+            197,
+            786,
+            805,
+            891
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 RESULTS ON KINETICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            375,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We further conduct experiments on large-scale video recognition benchmark, Kinetics-400, to evaluate the capability of our V4D. To make a fair comparison, we utilize ResNet50 as backbone for V4D. The training and inference sampling strategy is identical to previous section, except that each action unit now contains 8 frames instead of 4. We set $U = 4$ so that there are $8 \\times 4$ frames in total for training. Due to the limit of computation resource, we train the model in multiple stages. We first train the 3D ResNet50 backbone with 8-frame inputs. Then we load the 3D ResNet50 weights to V4D ResNet50, with all 4D Blocks fixed to zero. The V4D ResNet50 is then fine-tuned with $8 \\times 4$ input frames. Finally, we optimize all 4D Blocks, and train the V4D with $8 \\times 4$ frames. As shown in Table 4, our V4D achieves competitive results on Kinetics-400 benchmark. ",
+        "bbox": [
+            173,
+            130,
+            826,
+            256
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0ed8fb1fb9883efe07587e877df2c7e84cb0d18a2b3b7d3b9dc91ee8bddba413.jpg",
+        "table_caption": [
+            "Table 4: Comparison with state-of-the-art on Kinetics. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Backbone</td><td>top-1</td><td>top-5</td></tr><tr><td>ARTNet with TSN(Wang et al.,2018a)</td><td>ARTNetResNet18</td><td>70.7</td><td>89.3</td></tr><tr><td>ECO (Zolfaghari et al.,2018)</td><td>BN-Inception+3D ResNet18</td><td>70.0</td><td>89.4</td></tr><tr><td>S3D-G (Xie et al., 2018)</td><td>S3D Inception</td><td>74.7</td><td>93.4</td></tr><tr><td>Nonlocal Network(Wang et al.,2018a)</td><td>3DResNet50</td><td>76.5</td><td>92.6</td></tr><tr><td>SlowFast (Feichtenhofer et al.,2018)</td><td>SlowFast ResNet50</td><td>77.0</td><td>92.6</td></tr><tr><td>I3D(Carreira &amp; Zisserman,2017)</td><td>I3D Inception</td><td>72.1</td><td>90.3</td></tr><tr><td>Two-stream I3D(Carreira &amp; Zisserman,2017)</td><td>I3D Inception</td><td>75.7</td><td>92.0</td></tr><tr><td>I3D-S(Feichtenhofer et al., 2018)</td><td>Slow pathway ResNet50</td><td>74.9</td><td>91.5</td></tr><tr><td>V4D(Ours)</td><td>V4DResNet50</td><td>77.4</td><td>93.1</td></tr></table>",
+        "bbox": [
+            253,
+            270,
+            728,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 RESULTS ON SOMETHING-SOMETHING-V1 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            430,
+            509,
+            445
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Something-Something dataset focuses on modeling temporal information and motion. The background is much cleaner than Kinetics but the motions of action categories are more complicated. Each video contains one single and continuous action with clear start and end on temporal dimension. ",
+        "bbox": [
+            176,
+            457,
+            825,
+            500
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/8ad6cf10b5af6743983c54ed14a2f68665c78dce612fdbbff90188e5ff5158f7.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 5: Comparison with state-of-the-art on Something-Something-v1. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Backbone</td><td>top-1</td></tr><tr><td>MultiScale TRN (Zhou et al.,2018)</td><td>BN-Inception</td><td>34.4</td></tr><tr><td>ECO (Zolfaghari et al.,2018) S3D-G (Xie et al.,2018)</td><td>BN-Inception+3D ResNet18 S3D Inception</td><td>46.4 45.8</td></tr><tr><td>Nonlocal Network+GCN(Wang&amp; Gupta,2018)</td><td>3DResNet50</td><td>46.1</td></tr><tr><td>TrajectoryNet (Zhao et al.,2018)</td><td>S3D ResNet18</td><td>47.8</td></tr><tr><td>V4D(Ours)</td><td>V4DResNet50</td><td>50.4</td></tr></table>",
+        "bbox": [
+            264,
+            518,
+            712,
+            593
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. As shown in Table 4.4, our V4D achieves competitive results on the Something-Somethingv1. We use V4D ResNet50 pre-trained on Kinetics for experiments. Temporal Order. As shown in Xie et al. (2018), the performance can drop considerably by reversing the temporal order of short-term 3D features, suggesting that 3D CNNs can learn strong temporal order information. We further conduct experiments by reversing the frames within each action unit or reversing the sequence of action units, where the top-1 accuracy drops considerably by $5 0 . 4 \\%  1 7 . 2 \\%$ and $5 0 . 4 \\% {  } 2 0 . 1 \\%$ respectively, indicating that our V4D can capture both long-term and short-term temporal order. ",
+        "bbox": [
+            173,
+            623,
+            825,
+            722
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            744,
+            326,
+            760
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We have introduced new Video-level 4D Convolutional Neural Networks, namely V4D, to learn strong temporal evolution of long-range spatio-temporal representation, as well as retaining 3D features with residual connections. In addition, we further introduce the training and inference methods for our V4D. Experiments were conducted on three video recognition benchmarks, where our V4D achieved the state-of-the-art results. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            871,
+            285,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Joao Carreira and Andrew Zisserman. Quo vadis, action recognition? A new model and the kinetics˜ dataset. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Christopher Bongsoo Choy, JunYoung Gwak, and Silvio Savarese. 4d spatio-temporal convnets: Minkowski convolutional neural networks. CoRR, abs/1904.08755, 2019. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Donahue, Lisa Anne Hendricks, Sergio Guadarrama, Marcus Rohrbach, Subhashini Venugopalan, Kate Saenko, and Trevor Darrell. Long-term recurrent convolutional networks for visual recognition and description. In CVPR, 2015. ",
+        "bbox": [
+            176,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy, Philipp Fischer, Eddy Ilg, Philip Hausser, Caner Hazirbas, Vladimir Golkov, ¨ Patrick van der Smagt, Daniel Cremers, and Thomas Brox. Flownet: Learning optical flow with convolutional networks. In ICCV, 2015. ",
+        "bbox": [
+            174,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, and Kaiming He. Slowfast networks for video recognition. CoRR, abs/1812.03982, 2018. ",
+        "bbox": [
+            174,
+            244,
+            821,
+            273
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Raghav Goyal, Samira Ebrahimi Kahou, Vincent Michalski, Joanna Materzynska, Susanne Westphal, Heuna Kim, Valentin Haenel, Ingo Frund, Peter Yianilos, Moritz Mueller-Freitag, Florian Hoppe, ¨ Christian Thurau, Ingo Bax, and Roland Memisevic. The ”something something” video database for learning and evaluating visual common sense. In ICCV, 2017. ",
+        "bbox": [
+            173,
+            282,
+            826,
+            339
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            174,
+            348,
+            823,
+            378
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fabian Caba Heilbron, Victor Escorcia, Bernard Ghanem, and Juan Carlos Niebles. Activitynet: A large-scale video benchmark for human activity understanding. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            386,
+            821,
+            416
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In ICML, 2015. ",
+        "bbox": [
+            174,
+            425,
+            823,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shuiwang Ji, Wei Xu, Ming Yang, and Kai Yu. 3d convolutional neural networks for human action recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35:221–231, 2010. ",
+        "bbox": [
+            176,
+            462,
+            825,
+            492
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ivan Laptev, Marcin Marszalek, Cordelia Schmid, and Benjamin Rozenfeld. Learning realistic human actions from movies. In CVPR, 2008. ",
+        "bbox": [
+            173,
+            501,
+            825,
+            530
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Colin Lea, Rene Vidal, Austin Reiter, and Gregory D. Hager. Temporal convolutional networks: A ´ unified approach to action segmentation. In ECCV Workshops, 2016. ",
+        "bbox": [
+            171,
+            539,
+            825,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xingyu Liu, Joon-Young Lee, and Hailin Jin. Learning video representations from correspondence proposals. CoRR, abs/1905.07853, 2019. ",
+        "bbox": [
+            171,
+            577,
+            823,
+            606
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In ICML, 2010. ",
+        "bbox": [
+            171,
+            614,
+            823,
+            643
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joe Yue-Hei Ng, Matthew Hausknecht, Sudheendra Vijayanarasimhan, Oriol Vinyals, Rajat Monga, and George Toderici. Beyond short snippets: Deep networks for video classification. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A. J. Piergiovanni and Michael S. Ryoo. Representation flow for action recognition. CoRR, abs/1810.01455, 2018. ",
+        "bbox": [
+            169,
+            704,
+            825,
+            734
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhaofan Qiu, Ting Yao, and Tao Mei. Learning spatio-temporal representation with pseudo-3d residual networks. ICCV, 2017. ",
+        "bbox": [
+            169,
+            742,
+            825,
+            772
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Two-stream convolutional networks for action recognition in videos. In NIPS, 2014. ",
+        "bbox": [
+            173,
+            781,
+            823,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shuyang Sun, Zhanghui Kuang, Lu Sheng, Wanli Ouyang, and Wei Zhang. Optical flow guided feature: A fast and robust motion representation for video action recognition. In CVPR, 2018. ",
+        "bbox": [
+            173,
+            819,
+            823,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Du Tran, Lubomir D. Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. Learning spatiotemporal features with 3d convolutional networks. In ICCV, 2015. ",
+        "bbox": [
+            174,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Limin Wang, Yuanjun Xiong, Zhe Wang, Yu Qiao, Dahua Lin, Xiaoou Tang, and Luc Van Gool. Temporal segment networks: Towards good practices for deep action recognition. In ECCV, 2016. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Limin Wang, Wei Li, Wen Li, and Luc Van Gool. Appearance-and-relation networks for video classification. In CVPR, 2018a.   \nXiaolong Wang and Abhinav Gupta. Videos as space-time region graphs. In ECCV, 2018.   \nXiaolong Wang, Ross B. Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. In CVPR, 2018b.   \nSaining Xie, Chen Sun, Jonathan Huang, Zhuowen Tu, and Kevin Murphy. Rethinking spatiotemporal feature learning: Speed-accuracy trade-offs in video classification. In ECCV, 2018.   \nQuanzeng You and Hao Jiang. Action4d: Real-time action recognition in the crowd and clutter. CoRR, abs/1806.02424, 2018.   \nKaiyu Yue, Ming Sun, Yuchen Yuan, Feng Zhou, Errui Ding, and Fuxin Xu. Compact generalized non-local network. In NeurIPS, 2018.   \nBowen Zhang, Limin Wang, Zhe Wang, Yu Qiao, and Hanli Wang. Real-time action recognition with enhanced motion vector CNNs. In CVPR, 2016.   \nYue Zhao, Yuanjun Xiong, and Dahua Lin. Trajectory convolution for action recognition. In NeurIPS, 2018.   \nBolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep \\` features for discriminative localization. In CVPR, 2016.   \nBolei Zhou, Alex Andonian, Aude Oliva, and Antonio Torralba. Temporal relational reasoning in videos. In ECCV, 2018.   \nMohammadreza Zolfaghari, Kamaljeet Singh, and Thomas Brox. ECO: efficient convolutional network for online video understanding. In ECCV, 2018. ",
+        "bbox": [
+            171,
+            103,
+            828,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            297,
+            537
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.1 EXTENDED EXPERIMENTS ON LARGE-SCALE UNTRIMMED VIDEO RECOGNITION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            554,
+            769,
+            568
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In order to check the generalization ability of our proposed V4D, we also conduct experiments for untrimmed video classification. To be specific, we choose ActivityNet v1.3 Heilbron et al. (2015), which is a large-scale untrimmed video dataset, containing videos of 5 to 10 minutes and typically large time lapses of the videos are not related with any activity of interest. We adopt V4D ResNet50 to compare with previous works. During inference, Multi-scale Temporal Window Integration is applied following (Wang et al., 2016). The evaluation metric is mean average precision (mAP) for action recognition. Note that only RGB modality is used as input. ",
+        "bbox": [
+            173,
+            579,
+            826,
+            678
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/0f7ff0ff84172346c51bcc1c4f9f4c9bb9f9e22c5a99341decd94e51e9092ea1.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 6: Comparison with state-of-the-art on ActivityNet v1.3. "
+        ],
+        "table_body": "<table><tr><td>Model</td><td>Backbone</td><td>mAP</td></tr><tr><td>TSN Wang et al. (2016)</td><td>BN-Inception</td><td>79.7</td></tr><tr><td>TSN Wang et al. (2016)</td><td>Inception V3</td><td>83.3</td></tr><tr><td>TSN-Top3 Wang et al. (2016)</td><td>Inception V3</td><td>84.5</td></tr><tr><td>V4D(Ours)</td><td>V4DResNet50</td><td>88.9</td></tr></table>",
+        "bbox": [
+            341,
+            694,
+            635,
+            748
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.2 VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            795,
+            330,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We implement 3D CAM based on Zhou et al. (2016), which was originally implemented for 2D cases. Generally, class activation maps (CAM) imply which areas are most important for classification. Here we show some random visualization results from validation set of Mini-Kinetics, where $\\mathrm { T S N } +$ I3D-S ResNet18 generates wrong prediction while V4D ResNet18 generates correct prediction. The original RGB frames are shown in the first row. The second row shows the CAMs of $\\mathrm { T S N } + \\mathrm { I } 3 \\mathrm { D } { \\cdot } S$ ResNet18. The third row shows the CAMs of V4D ResNet18. ",
+        "bbox": [
+            173,
+            820,
+            826,
+            905
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/b2eb9226b6c08b44a02458da613f06777ce22d63977096f440eedebef08eacc8.jpg",
+        "image_caption": [
+            "Figure 3: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            133,
+            789,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/53ae42551d104ef05eff94b8d3a163a7559328f1248efe0c0c4185de64c8f5c3.jpg",
+        "image_caption": [
+            "Figure 4: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            547,
+            789,
+            869
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/aa212b08cf1798590b0acd37d54c446470023abcd2ab7feb69827194e66762ac.jpg",
+        "image_caption": [
+            "Figure 5: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            133,
+            789,
+            454
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/3a38a00777c730b10613b13fc067539d468825908e6ecaba924e0a5fd3f3df73.jpg",
+        "image_caption": [
+            "Figure 6: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            549,
+            787,
+            869
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/f4e2fca89d639fbc59d16a022dda0edf11da85ba63266482b5c1b96b4b90ccb3.jpg",
+        "image_caption": [
+            "Figure 7: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            133,
+            789,
+            455
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/0674e833ebe4676da479b168290180165c76c3cc69e89bf87f8edf207744d224.jpg",
+        "image_caption": [
+            "Figure 8: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            546,
+            789,
+            869
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/6799150db94b3ee2ade6b2373f4a1f40873e80ac59d22f5028fb1d64f6f4d347.jpg",
+        "image_caption": [
+            "Figure 9: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            133,
+            789,
+            454
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/444886b16851fd0913576d274d56a89cb777632696959a7c3768cce7af508b66.jpg",
+        "image_caption": [
+            "Figure 10: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            549,
+            789,
+            868
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/2224cb320bf5d5f4e6770f91a2829d414505899913a22c1d52acfc14425fdfc8.jpg",
+        "image_caption": [
+            "Figure 11: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            133,
+            789,
+            455
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa7b3bd413f4829644ad58768d16c44e36b976fb2db97c90ce134a9476c58648.jpg",
+        "image_caption": [
+            "Figure 12: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            549,
+            787,
+            869
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/e237ad16a83405351ce4e40de73b7fb84b335de365344481089b4cc7ebd413d4.jpg",
+        "image_caption": [
+            "Figure 13: "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            339,
+            789,
+            659
+        ],
+        "page_idx": 15
+    }
+]

parse/train/r1saNM-RW/r1saNM-RW.md

@@ -0,0 +1,500 @@
+# SMALL CORESETS TO REPRESENT LARGE TRAINING DATA FOR SUPPORT VECTOR MACHINES
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Despite their popularity, even efficient implementations of Support Vector Machines (SVMs) have proven to be computationally expensive to train at a largescale, especially in streaming settings. In this paper, we propose a coreset construction algorithm for efficiently generating compact representations of massive data sets to speed up SVM training. A coreset is a weighted subset of the original data points such that SVMs trained on the coreset are provably competitive with those trained on the original (massive) data set. We provide lower and upper bounds on the number of samples required to obtain accurate approximations to the SVM problem as a function of the complexity of the input data. Our analysis also establishes sufficient conditions on the existence of sufficiently compact and representative coresets for the SVM problem. We empirically evaluate the practical effectiveness of our algorithm against synthetic and real-world data sets.
+
+# 1 INTRODUCTION
+
+Popular machine learning algorithms are computationally expensive, or worse yet, intractable to train on Big Data. The notion of using coresets (Feldman & Langberg, 2011; Braverman et al., 2016; Bachem et al., 2017), small weighted subsets of the input points that provably approximate the original data set, has shown promise in accelerating machine learning algorithms such as $k$ - means clustering (Feldman & Langberg, 2011), mixture model training (Feldman et al., 2011; Lucic et al., 2017), and logistic regression (Huggins et al., 2016).
+
+Coreset constructions were originally introduced in the context of computational geometry (Agarwal et al., 2005) and subsequently generalized for applications to other problems (Langberg & Schulman, 2010; Feldman & Langberg, 2011). Coresets provide a compact representation of the structure of static and streaming data, with provable approximation guarantees with respect to specific algorithms. For instance, a data set consisting of $K$ clusters would yield a coreset of size $K$ , with each cluster represented by one coreset point. Even if the data has no structure (e.g., uniformly distributed), coresets will correctly down sample the data to within prescribed error bounds. For domains where the data has structure, the coreset representation has the potential to greatly and effectively reduce the time required to manually label data for training and the computation time for training, while at the same time providing a mechanism of supporting machine learning systems for applications with streaming data.
+
+Coresets are constructed by approximating the relative importance of each data point in the original data set to define a sampling distribution and sampling sufficiently many points in accordance with this distribution. This construction scheme suggests that beyond providing a means of conducting provably fast and accurate inference, coresets also serve as efficient representations of the full data set and may be used to automate laborious representation tasks, such as automatically generating semantic video representations or detecting outliers in data (Lucic et al., 2016).
+
+The representative power and provable guarantees provided by coresets also motivate their use in training of one of the most popular algorithms for classification and regression analysis: Support Vector Machines (SVMs). Despite their popularity, SVMs are computationally expensive to train on massive data sets, which has proven to be computationally problematic with the rising availability of Big Data. In this paper, we present a novel coreset construction algorithm for efficient, large-scale Support Vector Machine training.
+
+In particular, this paper contributes the following:
+
+1. A practical coreset construction algorithm for accelerating SVM training based on an efficient importance evaluation scheme for approximating the importance of each point.   
+2. An analysis proving lower bounds on the number of samples required by any coreset construction algorithm to approximately represent the data.   
+3. An analysis proving the efficiency and theoretical guarantees of our algorithm and characterizing the family of data sets for which applications of coresets are most suited.   
+4. Evaluations against synthetic and real-world data sets that demonstrate the practical effectiveness of our algorithm for large-scale SVM training.
+
+# 2 RELATED WORK
+
+Training a canonical Support Vector Machine (SVM) requires $\mathcal { O } ( n ^ { 3 } )$ time and $\mathcal { O } ( n ^ { 2 } )$ space where $n$ is the number of training points (Tsang et al., 2005). Work by Tsang et al. (2005) introduced Core Vector Machines (CVMs) that reformulated the SVM problem as the Minimum Enclosing Ball (MEB) problem and used existing coreset methods for MEB to compress the data. The authors proposed a method that generates a $( 1 + \varepsilon ) ^ { 2 }$ approximation to the two-class L2-SVM in $\mathcal { O } ( n / \varepsilon ^ { 2 } +$ $\bar { 1 } / \bar { \varepsilon ^ { 4 } } \rangle$ ) time, when certain assumptions about the kernel used are satisfied. However, CVM’s accuracy and convergence properties have been noted to be at times inferior to the performance of existing SVM implementations (Loosli & Canu, 2007). Similar geometric approaches including extensions to the MEB formulation, those based on convex hulls, and extreme points, among others, were also investigated by Rai et al. (2009); Agarwal & Sharathkumar (2010); Har-Peled et al. (2007); Nandan et al. (2014).
+
+Since the SVM problem is inherently a quadratic optimization problem, prior work has investigated approximations to the quadratic programming problem using the Frank-Wolfe algorithm or Gilbert’s algorithm (Clarkson, 2010). Another line of research has been in reducing the problem of polytope distance to solve the SVM problem (Gartner & Jaggi, 2009). The authors establish lower and upper ¨ bounds for the polytope distance problem and use Gilbert’s algorithm to train an SVM in linear time.
+
+A variety of prior approaches were based on randomized algorithms with the property that they generated accurate approximations with high probability. Most notable are the works of Clarkson et al. (2012) Hazan et al. (2011). Hazan et al. (2011) used a primal-dual approach combined with Stochastic Gradient Descent (SGD) in order to train linear SVMs in sub-linear time. They proposed the SVM-SIMBA approach and proved that it generates an $\varepsilon$ -approximate solution with probability at least $1 / 2$ to the SVM problem that uses hinge loss as the objective function. The key idea in their method is to access single features of the training vectors rather than the entire vectors themselves. Their method is nondeterministic and returns the correct $\varepsilon$ -approximation with probability greater than a constant probability, similar to the probabilistic guarantees of coresets.
+
+Clarkson et al. (2012) present sub-linear-time (in the size of the input) approximation algorithms for some optimization problems such as training linear classifiers (e.g., perceptron) and finding MEB. They introduce a technique that is originally applied to the perceptron algorithm, but extend it to the related problems of MEB and SVM in the hard margin or $L 2$ -SVM formulations. Shalev-Shwartz et al. (2011) introduce Pegasos, a stochastic sub-gradient algorithm for approximately solving the SVM optimization problem, that runs in $\widetilde { \mathcal { O } } ( d n C / \varepsilon )$ time for a linear kernel, where $C$ is the SVM regularization parameter and $d$ is the dimensionality of the input data points. These works offer probabilistic guarantees, similar to those provided by coresets, and have been noted to perform well empirically; however, unlike coresets, SGD-based approaches cannot be trivially extended to streaming settings since each new arriving data point in the stream results in a change of the gradient.
+
+Joachims (2006) presents an alternative approach to training SVMs in linear time based on the cutting plane method that hinges on an alternative formulation of the SVM optimization problem. He shows that the Cutting-Plane algorithm can be leveraged to train SVMs in $\mathcal { O } ( s n )$ time for classification and $\mathcal { O } ( s n \log n )$ time for ordinal regression where $s$ is the average number of non-zero features. Har-Peled et al. (2007) constructs coresets to approximate the maximum margin separation, i.e., a hyperplane that separates all of the input data with margin larger than $( 1 - \varepsilon ) \rho ^ { * }$ , where $\rho ^ { * }$ is the best achievable margin.
+
+# 3 PROBLEM DEFINITION
+
+# 3.1 SOFT-MARGIN SVM
+
+We assume that we are given a set of weighted training points $\mathcal { P } = \{ ( x _ { i } , y _ { i } ) \} _ { i = 1 } ^ { n }$ with the corresponding weight function $u : \mathcal { P }  \mathbb { R } _ { \geq 0 }$ , such that for every $i \in [ n ]$ , $x _ { i } \in \mathbb { R } ^ { d }$ , $y _ { i } \in \{ - 1 , 1 \}$ , and $u ( p _ { i } )$ corresponds to the weight of point $p _ { i }$ . For simplicity, we assume that the bias term is embedded into the feature space by defining $\tilde { x } _ { i } = ( x _ { i } , 1 )$ for each point and $\tilde { w } = ( w , 1 )$ for each query. Thus, we henceforth assume that we are dealing with $d + 1$ dimensional points and refer to $\tilde { w }$ and $\tilde { x } _ { i }$ as just $w$ and $x _ { i }$ respectively. Under this setting, the hinge loss of a point $p _ { i } = ( x _ { i } , y _ { i } )$ with respect to the separating hyperplane $w$ is defined as $h ( \bar { p } _ { i } , w ) = \bar { [ 1 - y _ { i } \langle x _ { i } , \bar { w } \rangle ] } _ { + }$ , where $[ x ] _ { + } = \operatorname* { m a x } \{ 0 , x \}$ .
+
+For any subset of points, $\mathcal { P } ^ { \prime } \subseteq \mathcal { P }$ , define $\begin{array} { r } { { \cal H } ( { \mathcal P } ^ { \prime } , w ) = \sum _ { p \in { \mathcal P } ^ { \prime } } u ( p ) h ( p , w ) } \end{array}$ as the sum of the hinge losses and $\begin{array} { r } { u ( \mathcal { P } ^ { \prime } ) = \sum _ { p \in \mathcal { P } ^ { \prime } } u ( p ) } \end{array}$ as the sum of the weights of points in set $\mathcal { P } ^ { \prime }$ . To clearly depict the contribution of each point to the objective value of the SVM problem, we present the SVM objective function, $f ( \mathcal { P } , w )$ , as the sum of per-point objective function evaluations, which we formally define below.
+
+Definition 1 (Per-point Objective Function). Define the function $f : ( \mathbb { R } ^ { d + 1 } \times \{ - 1 , 1 \} ) \times \mathbb { R } ^ { d + 1 } \to$ $\mathbb { R } _ { \geq 0 }$ such that for every $i \in [ n ]$
+
+$$
+f ( \boldsymbol { p } _ { i } , \boldsymbol { w } ) = \frac { \left\| \boldsymbol { w } _ { 1 : d } \right\| _ { 2 } ^ { 2 } } { 2 u ( \mathcal { P } ) } + C h ( \boldsymbol { p } _ { i } , \boldsymbol { w } ) ,
+$$
+
+$w _ { 1 : d }$ denotes the entries $1 : d$ of $w$ , $h ( p _ { i } , w )$ is the corresponding hinge loss, and $C \in [ 0 , 1 ]$ is the regularization parameter.
+
+Definition 2 (Soft-margin SVM Problem). Given a set of $d + 1$ dimensional weighted points $\mathcal { P }$ with weight function $u : \mathcal { P }  \mathbb { R } _ { \geq 0 }$ the primal of the SVM problem is expressed by the following quadratic program
+
+$$
+\operatorname* { m i n } _ { w \in \mathcal { Q } } f ( ( \mathcal { P } , u ) , w ) ,
+$$
+
+where $f$ is the evaluation of the weighted point set $\mathcal { P }$ with weight function $u : \mathcal { P }  \mathbb { R } _ { \geq 0 }$ ,
+
+$$
+f ( ( \mathcal P , u ) , w ) = \sum _ { i \in [ n ] } u ( p _ { i } ) f ( p _ { i } , w ) = \frac { \| w _ { 1 : d } \| _ { 2 } ^ { 2 } } { 2 } + C H ( \mathcal P , w ) .
+$$
+
+When the set of points $\mathcal { P }$ and the corresponding weight function $u$ are clear from context, we will henceforth denote $f ( ( \mathcal { P } , u ) , w )$ by $f ( \mathcal { P } , w )$ for notational convenience.
+
+# 3.2 CORESETS
+
+Coresets can be seen as a compact representation of the full data set that approximate the SVM cost function (2) uniformly over all queries $w \in \mathcal { Q }$ . Thus, rather than introducing an entirely new algorithm for solving the SVM problem, our approach is to reduce the runtime of standard SVM algorithms by compressing the size of the input points from $n$ to a compact set whose size is sublinear (ideally, polylogarithmic) in $n$ .
+
+Definition 3 $\varepsilon$ -coreset). Let $\varepsilon \in ( 0 , 1 / 2 )$ and $\mathcal { P } \subset \mathbb { R } ^ { d + 1 } \times \{ - 1 , 1 \}$ be a set of $n$ weighted points with weight function $u : \mathcal { P }  \mathbb { R } _ { \geq 0 }$ . The weighted subset $( \boldsymbol { S } , \boldsymbol { v } )$ , where $\mathcal { S } \subset \mathcal { P }$ with corresponding weight function $v : { \mathcal { S } }  \mathbb { R } _ { \geq 0 }$ is an $\varepsilon$ -coreset if for any query $w \in \mathcal { Q } , ( S , v )$ satisfies the coresetproperty
+
+$$
+| f \left( ( \mathcal { P } , u ) , w \right) - f \left( ( S , v ) , w \right) | \leq \varepsilon f \left( ( \mathcal { P } , u ) , w \right) \ ( C o r e s e t P r o p e r t y ) .
+$$
+
+Our overarching goal is to efficiently construct an $\varepsilon$ -coreset, $( \boldsymbol { S } , \boldsymbol { v } )$ , such that the size of $s$ is sufficient small in comparison to the original number of points $n$ .
+
+# 4 METHOD
+
+# 4.1 METHOD OVERVIEW
+
+Our coreset construction scheme is based on the unified framework of Langberg & Schulman (2010); Feldman & Langberg (2011) and is shown as Alg. 1. The crux of our algorithm lies in generating the importance sampling distribution via efficiently computable upper bounds (proved in Sec. 5) on the importance of each point (Lines 1-6). Sufficiently many points are then sampled from this distribution and each point is given a weight that is inversely proportional to its sample probability (Lines 7-9). The number of points required to generate an $\varepsilon$ -coreset with probability at least $1 - \delta$ is a function of the desired accuracy $\varepsilon$ , failure probability $\delta$ , and complexity of the data set ( $t$ from Theorem 9). Under mild assumptions on the problem at hand (see Sec. 5.2), the required sample size is polylogarithmic in $n$ .
+
+Intuitively, our algorithm can be seen as an importance sampling procedure that first generates a judicious sampling distribution based on the structure of the input points and samples sufficiently many points from the original data set. The resulting weighted set of points, $( S , v )$ , serves as an unbiased estimator for $f ( \mathcal { P } , w )$ for any query $w \in \mathcal { Q }$ , i.e., $\mathbb { E } [ f \left( ( S , v ) , w \right) ] = f ( \mathcal { P } , w )$ . Although sampling points uniformly with appropriate weights can also generate such an unbiased estimator, it turns out that the variance of this estimation is minimized if the points are sampled according to the distribution defined by the ratio between each point’s sensitivity and the sum of sensitivities, i.e., $\gamma ( p _ { i } ) / t$ on Line 9 (Bachem et al., 2017).
+
+# 4.2 CHICKEN AND THE EGG PHENOMENA
+
+Coresets are intended to provide efficient and provable approximations to the optimal SVM solution, however, the very first line of our algorithm entails computing the optimal solution to the SVM problem. This seemingly eerie phenomenon is explained by the merge-and-reduce technique (Har-Peled & Mazumdar, 2004) that ensures that our coreset algorithm is only run against small partitions of the original data set (Har-Peled & Mazumdar, 2004; Braverman et al., 2016; Lucic et al., 2017). The merge-and-reduce approach leverages the fact that coresets are composable and reduces the coreset construction problem for a (large) set of $n$ points into the problem of computing coresets for $\frac { n } { 2 | S | }$ points, where $2 | S |$ is the minimum size of input set that can be reduced to half using Alg. 1 (Braverman et al., 2016). Assuming that the sufficient conditions for obtaining polylogarithmic size coresets implied by Theorem 9 hold, the overall time required for coreset construction is nearly linear in $n$ , $\widetilde { \mathcal { O } } _ { \varepsilon , \delta } ( d ^ { 3 } n ) ^ { 1 }$ . This follows from the fact that $2 | \bar { S } | = \widetilde { \mathcal { O } } _ { \delta , \varepsilon } ( d )$ by Theorem 9, that the Interior Point Method runs in time $\mathcal { O } ( | S | ^ { 3 } ) = \tilde { \mathcal { O } } _ { \delta , \varepsilon } ( d ^ { 3 } )$ for an input set of size $2 | S |$ , and that the merge-and-reduce tree has height at most $\lceil \log n \rceil$ , meaning that an accuracy parameter of $\varepsilon ^ { \prime } = \varepsilon / \log n$ has to be used in the intermediate coreset constructions to account for the compounded error over all levels of the tree (Braverman et al., 2016).
+
+# 4.3 EXTENSIONS
+
+We briefly remark on a straightforward extension that can be made to our algorithm to accelerate performance and applicability. In particular, the computation of the optimal solution to the SVM problem in line 1 can be replaced by an efficient gradient-based method, such as Pegasos (ShalevShwartz et al., 2011), to compute an approximately $\xi$ optimal solution in $\widetilde { \mathcal { O } } \left( d n C / \bar { \xi } \right)$ time, which is particularly suited to scenarios with $C$ small. We give this result as Lemma 11, an extension of Lemma 7. We also note that based on our analytical results (Lemmas 7 and 11), any SVM solver, either exact or approximate, can be used in Line 1 as a replacement for the Interior Point Method.
+
+# 5 ANALYSIS
+
+In this section, we prove upper and lower bounds on the sensitivity of a point in terms of the complexity of the given data set. Our main result is Theorem 9, which establishes sufficient conditions
+
+# Algorithm 1: CORESET(P, u, ε, δ)
+
+Input: A set of training points $\mathcal { P } \subseteq \mathbb { R } ^ { d + 1 } \times \{ - 1 , 1 \}$ containing $n$ points, a weight function $u : \mathcal { P } \to { \mathbb { R } } _ { \geq 0 }$ , an error parameter $\varepsilon \in ( 0 , 1 )$ , and failure probability $\delta \in ( 0 , 1 )$ .
+
+Output: An $\varepsilon$ -coreset $( \boldsymbol { S } , \boldsymbol { v } )$ with probability at least $1 - \delta$
+
+// Compute the optimal solution using an Interior Point Method.
+
+$K _ { y _ { i } } \gets u ( \mathcal { P } _ { y _ { i } } ^ { \mathrm { c } } ) / \left( 2 u ( \mathcal { P } ) \cdot u ( \mathcal { P } _ { y _ { i } } ) \right)$ for each $y _ { i } \in \{ - 1 , 1 \}$
+
+// Compute an upper bound for the sensitivity of each point according to Eqn.(5).
+
+3 for $i \in [ n ]$ do
+
+6 t ← Pi∈[n] γ(pi)   
+7 Let
+
+$$
+m \gets \Omega \left( \frac { t } { \varepsilon ^ { 2 } } \big ( d \log t + \log ( 1 / \delta ) \big ) \right)
+$$
+
+8 $( K _ { 1 } , \ldots , K _ { n } ) \sim$ Multinomial $( m , \pi _ { i } = \gamma ( p _ { i } ) / t \forall i \in [ n ] )$   
+9 $S \gets \{ p _ { i } \in \mathcal { P } : K _ { i } > 0 \}$   
+// Compute the weights $v : S \to \mathbb { R } _ { \geq 0 }$ for every point $p _ { i } \in \mathcal S$ .   
+10 for $i \in [ n ]$ do   
+11 $\begin{array} { r l } { \bigg | } & { { } v ( p _ { i } )  \frac { t K _ { i } u ( p _ { i } ) } { \gamma ( p _ { i } ) | S | } } \end{array}$   
+12 return $( \boldsymbol { S } , \boldsymbol { v } )$
+
+for the existence of small coresets depending on the properties of the data. Our theoretical results also highlight the influence of the regularization parameter, $C$ , in the size of the coreset.
+
+Definition 4 (Sensitivity (Braverman et al., 2016)). The sensitivity of an arbitrary point $p \in \mathcal P$ , $p = ( x , y )$ is defined as
+
+$$
+s ( p ) = \operatorname* { s u p } _ { w \in \mathcal { Q } } \ \frac { u ( p ) f ( p , w ) } { \sum _ { q \in \mathcal { P } } u ( q ) f ( q , w ) } ,
+$$
+
+where $u : \mathcal { P }  \mathbb { R } _ { \geq 0 }$ is the weight function as before.
+
+# 5.1 SENSITIVITY LOWER BOUND
+
+We first prove the existence of a hard point set for which the sum of sensitivities is approximately $\Omega ( n C )$ , ignoring $d$ factors, which suggests that if the regularization parameter is too large, then the required number of samples for property (3) to hold is $\bar { \Omega ( n ) }$ .
+
+Lemma 5. There exists a set of $n$ points $\mathcal { P }$ such that the sensitivity of each point $p _ { i }$ is bounded below by $\begin{array} { r } { \Omega \left( \frac { d ^ { 2 } + n C } { n \left( C + d ^ { 2 } \right) } \right) } \end{array}$ and the sum of sensitivities is bounded below by $\Omega \left( \textstyle { \frac { d ^ { 2 } + n C } { C + d ^ { 2 } } } \right)$ .
+
+The same hard point set from Lemma 5 can be used to also prove a bound that is nearly exponential in the dimension, $d$ .
+
+Corollary 6. There exists a set of $\Omega \left( \frac { d ^ { 2 } + { \cal C } \left( 2 ^ { d } / \sqrt { d } \right) } { d ^ { 2 } + { \cal C } } \right) ,$ . $n$ points $\mathcal { P }$ such that the total sensitivity is bounded below by
+
+We next prove upper bounds on the sensitivity of each data point with respect to the complexity of the input data. Despite the non-existence results established above, our upper bounds shed light into the class of data sets for which coresets of sufficiently small size exist, and thus have potential to significantly speed up SVM training.
+
+# 5.2 SENSITIVITY UPPER BOUND
+
+For any arbitrary point $p = ( x _ { i } , y _ { i } ) \in \mathcal { P }$ , let $\mathcal { P } _ { y _ { i } } \subset \mathcal { P }$ denote the set of points of label $y _ { i }$ , let $\mathcal { P } _ { y _ { i } } ^ { \mathsf { c } } = \mathcal { P } \setminus \mathcal { P } _ { y _ { i } }$ be its complement, and let $w ^ { * }$ denote the optimal solution to the SVM problem (2). We assume that the points are normalized to have a Euclidean norm of at most one, i.e., $\forall ( x , y ) \in \mathcal { P } \ \| x _ { 1 : d } \| _ { 2 } \leq 1$ , where $x _ { 1 : d }$ refers to original input point, without the bias embedding.
+
+Lemma 7. The sensitivity of any point $p _ { i } \in \mathcal { P }$ is bounded above by
+
+$$
+\langle p _ { i } \rangle \le \frac { u ( p _ { i } ) } { u ( \mathcal { P } _ { y _ { i } } ) } + \frac { C u ( p _ { i } ) } { 2 f ( \mathcal { P } , w ^ { * } ) } \left( \sqrt { \left( \langle w ^ { * } , p _ { \Delta } \rangle - \frac { K _ { y _ { i } } } { C } \right) ^ { 2 } + 2 f ( \mathcal { P } , w ^ { * } ) \left. p _ { \Delta } \right. _ { 2 } ^ { 2 } } + \langle w ^ { * } , p _ { \Delta } \rangle - \frac { K _ { y _ { i } } } { C } \right)
+$$
+
+where $p _ { \Delta } = \bar { p } _ { y _ { i } } - p _ { i }$ and $K _ { y _ { i } } = u ( \mathcal { P } _ { y _ { i } } ^ { \mathsf { c } } ) / ( 2 u ( \mathcal { P } ) \cdot u ( \mathcal { P } _ { y _ { i } } ) ) .$
+
+Let $\mathcal { P } _ { + } = \mathcal { P } _ { 1 } \subset \mathcal { P }$ and $\mathcal { P } _ { - } = \mathcal { P } \setminus \mathcal { P } _ { 1 }$ denote the set of points with positive and negative labels respectively. Let $\bar { p } _ { + }$ and $\bar { p } _ { - }$ denote the weighted mean of the positive and labeled points respectively, and for any $p _ { i } \in \mathcal { P } _ { + }$ let $\bar { p } _ { \Delta _ { i } } ^ { + } = \bar { p } _ { + } - p _ { i }$ and $p _ { \Delta _ { i } } ^ { - } = \bar { p } _ { - } - p _ { i }$ .
+
+Lemma 8. The sum of sensitivities over all points $\mathcal { P }$ is bounded by
+
+$$
+S ( \mathcal { P } ) \mathop { \le } 2 + \frac { C \left( V a r ( \mathcal { P } _ { + } ) + V a r ( \mathcal { P } _ { - } ) \right) } { \sqrt { f ( \mathcal { P } , w ^ { * } ) } } = t ,
+$$
+
+where $f ( \mathcal { P } , w ^ { * } )$ is the optimal value of the SVM problem, and $V a r ( \mathcal { P } _ { + } )$ and $V a r ( \mathcal { P } _ { - } )$ denote the total deviation of positive and negative labeled points from their corresponding label-specific mean
+
+$$
+\begin{array} { l } { { \displaystyle V a r ( \mathcal P _ { + } ) = \sum _ { p _ { i } \in \mathcal P _ { + } } u ( p _ { i } ) \left\| p _ { \Delta _ { i } } ^ { + } \right\| _ { 2 } = \sum _ { p _ { i } \in \mathcal P _ { + } } u ( p _ { i } ) \left\| \bar { p } _ { + } - p _ { i } \right\| _ { 2 } } } \\ { { \displaystyle V a r \left( \mathcal P _ { - } \right) = \sum _ { p _ { i } \in \mathcal P _ { - } } u ( p _ { i } ) \left\| p _ { \Delta _ { i } } ^ { - } \right\| _ { 2 } = \sum _ { p _ { i } \in \mathcal P _ { - } } u ( p _ { i } ) \left\| \bar { p } _ { - } - p _ { i } \right\| _ { 2 } . } } \end{array}
+$$
+
+Theorem 9. Given any $\varepsilon \in ( 0 , 1 / 2 ) , \delta \in ( 0 , 1 )$ and a weighted data set $\mathcal { P }$ with corresponding weight function $u$ , with probability greater than $1 - \delta$ , Algorithm $^ { l }$ generates an $\varepsilon$ -coreset, i.e., a weighted set $( \boldsymbol { S } , \boldsymbol { v } )$ , of size
+
+$$
+\mathcal { S } \in \Omega \left( \frac { t } { \varepsilon ^ { 2 } } \big ( d \log t + \log ( 1 / \delta ) \big ) \right)
+$$
+
+in $\mathcal { O } ( n ^ { 3 } )$ time, where $t$ is the upper bound on the sum of sensitivities from Lemma 8,
+
+$$
+t = 2 + \frac { C \left( V a r ( \mathcal { P } _ { + } ) + V a r ( \mathcal { P } _ { - } ) \right) } { \sqrt { f ( \mathcal { P } , w ^ { * } ) } } .
+$$
+
+For any subset $T \subseteq { \mathcal { P } }$ , let $w _ { T } ^ { * }$ denote the optimal separating hyperplane with respect to the set of points in $T$ . The following corollary immediately follows from Theorem 9 and implies that training an SVM on an $\varepsilon$ -coreset, $( \boldsymbol { S } , \boldsymbol { v } )$ , to obtain $w _ { s } ^ { * }$ yields a solution that is provably competitive with the optimal solution on the full data-set, $\boldsymbol { w _ { \mathcal { P } } ^ { * } } = \boldsymbol { w } ^ { * }$ .
+
+Corollary 10. Given any $\varepsilon \in ( 0 , 1 / 2 ) , \delta \in ( 0 , 1 )$ and a weighted data set $( \mathcal { P } , u )$ , the weighted set of points $( \boldsymbol { S } , \boldsymbol { v } )$ generated by Alg. 1 satisfies
+
+$$
+f ( ( \mathcal { P } , u ) , w _ { \mathcal { S } } ^ { * } ) \leq ( 1 + 4 \varepsilon ) f ( ( \mathcal { P } , u ) , w _ { \mathcal { P } } ^ { * } ) ,
+$$
+
+with probability greater than $1 - \delta$ .
+
+Sufficient Conditions Theorem 9 immediately implies that, for reasonable $\varepsilon$ and $\delta$ , coresets of polylogarithmic (in $n$ ) size can be obtained if $d = \mathcal { O } ( \mathrm { p o l y l o g } ( n ) )$ , which is usually the case in our target applications, and if
+
+$$
+\frac { C \left( \mathrm { V a r } ( \mathcal { P } _ { + } ) + \mathrm { V a r } ( \mathcal { P } _ { - } ) \right) } { \sqrt { f ( \mathcal { P } , w ^ { * } ) } } = \mathcal { O } ( \mathrm { p o l y l o g } ( n ) ) .
+$$
+
+For example, a value of $C \leq { \frac { \log n } { n } }$ for the regularization parameter $C$ satisfies the sufficient condition for all data sets with normalized points.
+
+Interpretation of Bounds Our approximation of the sensitivity of a point $p _ { i } \in \mathcal { P }$ , i.e., its relative importance, is a function of the following highly intuitive variables.
+
+1. Relative weight with respect to the weights of points of the same label $\left( u ( p _ { i } ) / u ( \mathcal { P } _ { y _ { i } } ) \right)$ : the sensitivity increases as this ratio increases.   
+2. Distance to the label-specific mean point $\left( \Vert \bar { p } _ { y _ { i } } - p _ { i } \Vert _ { 2 } \right)$ : points that are considered outliers with respect to the label-specific cluster are assigned higher importance.   
+3. Distance to the optimal hyperplane $( \langle w ^ { * } , p _ { \Delta } \rangle )$ : importance increases as distance of the difference vector $p _ { \Delta } = \bar { p } _ { y _ { i } } - p _ { i }$ to the optimal hyperplane increases.
+
+Note that the sum of sensitivities, which dictates how many samples are necessary to obtain an $\varepsilon$ - coreset with probability at least $1 - \delta$ and in a sense measures the difficulty of the problem, increases monotonically with the sum of distances of the points from their label-specific means.
+
+# 5.3 EXTENSIONS
+
+We conclude our analysis with an extension of Lemma 7 to the case where only an approximately optimal solution to the SVM problem is available.
+
+Lemma 11. Consider the case where only a $\xi$ -approximate solution $\hat { w }$ is available such that $f ( \mathcal { P } , \hat { w } ) \leq f ( \mathcal { P } , w ^ { * } ) + \xi ,$ , for $\xi \in ( 0 , f ( \mathcal { P } , w ^ { * } ) / 2 )$ . Then, the sensitivity of any arbitrary point $p _ { i } \in \mathcal { P }$ is bounded above by
+
+$$
+\left. p _ { i } \right. \le \frac { u ( p _ { i } ) } { u ( \mathcal { P } _ { y _ { i } } ) } + \frac { C u ( p _ { i } ) \left( \sqrt { \left( \left. \hat { w } , p _ { \Delta } \right. - \frac { K _ { y _ { i } } } { C } \right) ^ { 2 } + 4 \left( f ( \mathcal { P } , \hat { w } ) - 2 \xi \right) \left. p _ { \Delta } \right. _ { 2 } ^ { 2 } } + \left. \hat { w } , p _ { \Delta } \right. - \frac { K _ { y _ { i } } } { C } \right) } { 2 \left( f ( \mathcal { P } , \hat { w } ) - 2 \xi \right) } ,
+$$
+
+where $p _ { \Delta } = \bar { p } _ { y _ { i } } - p _ { i }$ and $K _ { y _ { i } } = u ( \mathcal { P } _ { y _ { i } } ^ { \mathrm { c } } ) / \left( 2 u ( \mathcal { P } ) \cdot u ( \mathcal { P } _ { y _ { i } } ) \right)$ as in Lemma 7.
+
+# 6 RESULTS
+
+We evaluate the performance of our coreset construction algorithm against synthetic and real-world, publicly available data sets (Lichman, 2013). We compare the effectiveness of our method to uniform subsampling on a wide variety of data sets and also to Pegasos, one of the most popular Stochastic-Gradient Descent based algorithm for SVM training (Shalev-Shwartz et al., 2011). For each data set of size $N$ , we selected a set of $M = 1 0$ subsample sizes $S _ { 1 } , \ldots , S _ { \mathrm { M } } \subset [ N ]$ and ran each coreset construction algorithm to construct and evaluate the accuracy subsamples sizes $S _ { 1 } , \ldots , S _ { \bf M }$ . The results were averaged across 100 trials for each subsample size. Our results of relative error and sampling variance are shown as Figures 1 and 3. The computation time required for each sample size and approach can be found in the Appendix (Fig. 4). Our experiments were implemented in Python and performed on a 3.2GHz i7-6900K (8 cores total) machine with 16GB RAM. We considered the following data sets for evaluation.
+
+• Pathological — 1, 000 points in two dimensional space describing two clusters distant from each other of different labels, as well as two points of different labels which are close to each other. We note that uniform sampling performs particularly poorly against this data set due to the presence of outliers.   
+• Synthetic & Synthetic100K— The Synthetic and Synthetic100K are datasets with 6, 000, 100, 000 points, each consisting of 3 and 4 dimensions respectively. The datasets describe two blocks of mirrored nested rings of points, each of different labels such that Gaussian noise has been added to them. HTRU2 — 17, 898 radio emissions of Pulsar (rare type of Neutron star) each consisting of 9 features.   
+• CreditCard 3— 30, 000 client entries each consisting of 24 features that include education, age, and gender among other factors.
+
+• $S k i n ^ { 4 } - 2 4 5 , 0 5 7$ random samples of B,G,R from face images consisting of 4 dimensions.
+
+Evaluation We computed the relative error of the sampling-based algorithms with respect to the cost of the optimal solution to the SVM problem, $f ( \mathcal { P } , w _ { \mathcal { P } } ^ { * } )$ and the approximate cost generated by the subsample, $f ( ( \boldsymbol { S } , \boldsymbol { v } ) , \boldsymbol { w } _ { \boldsymbol { S } } ^ { * } )$ . We have also evaluated against Pegasos, running Pegasos the amount of time needed to construct the coreset and comparing the resulted error, applying 128 repetitions as presented at Figure 2. Furthermore, we have run our coreset constructing under streaming setting, where subsamples are used as leaf size and half of the leaf’s size is then used to set the subsample for our sampling approach. In addition, we also compared our coreset construction’s related error to CVM’s related error with respect to the cost of the optimal solution to the SVM problem, as function of subsample sizes. Finally, we have evaluated the variance of the estimators for the sampling-based approaches and observed that the variances of the estimates generated by our coreset were lower than those of uniform subsampling.
+
+![](images/69649f45f8a344a1663cc31d3a62823ee90b5f60d490ff7e8e7763715c3a203d.jpg)  
+Figure 1: The relative error of query evaluations with respect uniform and coreset subsamples for the 4 data sets.
+
+![](images/5848e6da3f62659fc0bec82a38c2d9de2e4152022fca4af30a439888d3f26eca.jpg)  
+Figure 2: The relative error of query evaluations with respect to coreset running time and Pegasos running time for the 4 data sets.
+
+# 7 CONCLUSION
+
+We presented an efficient coreset construction algorithm for generating compact representations of the input data points that provide provably accurate inference. We presented both lower and upper bounds on the number of samples required to obtain accurate approximations to the SVM problem as a function of input data complexity and established sufficient conditions for the existence of compact representations. Our experimental results demonstrate the effectiveness of our approach in speeding up SVM training when compared to uniform sub-sampling
+
+The method presented in this paper is also applicable to streaming settings, using the merge-andreduce technique from coresets literature (Braverman et al., 2016).We conjecture that our coreset construction method can be extended to significantly speed up SVM training for nonlinear kernels as well as other popular machine learning algorithms, such as deep learning.
+
+# 8 APPENDIX
+
+![](images/4d7200ab6ce7cd65036f493e8ec2b2b133f0893122502b8d51c6190c28480962.jpg)  
+Figure 3: The estimator variance of query evaluations. We note that due to the use of a judicious sampling distribution based on the points’ sensitivities, the variance of our coreset estimator is lower than that of uniform sampling for all data sets.
+
+# 8.1 PROOF OF LEMMA 5
+
+Proof. Following Yang et al. (2017) we define the set of $n$ points $\mathcal { P } \subseteq \mathbb { R } ^ { d + 1 } \times \{ - 1 , 1 \}$ , each point $p \in \mathcal P$ with weight $u ( \bar { p } ) = 1$ , such that for each $i \in [ n ]$ , among the first $d$ entries of $p _ { i }$ , exactly $d / 2$ entries are equivalent to $\gamma$ :
+
+$$
+\gamma = \sqrt { \frac { R + 1 } { d } } ,
+$$
+
+where $R$ is the normalization factor (typically $R = 1$ ), the remaining $d / 2$ entries among the first $d$ are set to $_ 0$ , and $p _ { i ( d + 1 ) } = y _ { i }$ as before. For each $i \in [ n ]$ , define the set of non-zero entries of $p _ { i }$ as the set
+
+$$
+B _ { i } = \{ j \in [ d + 1 ] : p _ { i j } \neq 0 \} .
+$$
+
+Now, for bounding the sensitivity of point $p _ { i }$ , consider the normal to the margin $w _ { i }$ with entries defined as
+
+$$
+\forall j \in [ d + 1 ] ~ w _ { i j } = \left\{ { \begin{array} { l l } { 0 ~ { \mathrm { i f } } ~ j \in B _ { i } , } \\ { 1 / \gamma ~ { \mathrm { o t h e r w i s e } } . } \end{array} } \right.
+$$
+
+Note that for $R = 1$ , $| | w _ { i } | | ^ { 2 } = ( d / 2 ) ( 1 / \gamma ^ { 2 } ) = ( d / 2 ) d / ( R + 1 ) = d ^ { 2 } / 4$ . We also have that $h ( w _ { i } , p _ { i } ) = 1$ since $\begin{array} { r } { p _ { i } \cdot w _ { i } = \sum _ { l \in B _ { i } } p _ { i j } w _ { i j } = ( d / 2 ) ( 0 ) = 0 . } \end{array}$ . To bound the sum of hinge losses
+
+![](images/f28c5d9f43603b4422507063de3117115d9b594cb6b2ef41a443fa164e371172.jpg)  
+Figure 4: Computation $^ +$ Training Time vs. Sample Size
+
+![](images/e988f3a1b836f4b60a26c78ae3a801b7254ac0a63ba8952633a1857d4b7629b4.jpg)  
+Figure 5: The relative error of query evaluations with respect uniform and coreset subsamples for the 5 data sets in a streaming setting where the input points arrive one-by-one.
+
+contributed by other points $j \in [ n ]$ , $j \neq i$ note that $B _ { i } \setminus B _ { j } \ne \emptyset$ , thus:
+
+$$
+\langle w _ { i } , p _ { j } \rangle = \sum _ { l \in B _ { i } \backslash B _ { j } } w _ { i l } p _ { j l } \geq \gamma ( 1 / \gamma ) = 1 ,
+$$
+
+which implies that $h ( p _ { j } , w _ { i } ) = 0$ . Thus, it follows that $\begin{array} { r } { H ( w _ { i } ) = \sum _ { j \in [ n ] } h ( p _ { j } , w _ { i } ) = 1 } \end{array}$
+
+Putting it all together, we have for the sensitivity of any arbitrary $i \in [ n ]$ :
+
+$$
+s ( p _ { i } ) = \operatorname* { s u p } _ { w \in \mathcal { Q } } \frac { f ( p _ { i } , w ) } { \sum _ { j \in [ n ] } f ( p _ { j } , w ) } \geq \frac { \frac { d ^ { 2 } } { 8 n } + C h ( p _ { i } , w _ { i } ) } { \frac { | | w _ { i } | | ^ { 2 } } { 2 } + C } = \frac { \frac { d ^ { 2 } } { 8 n } + C } { \frac { d ^ { 2 } } { 8 } + C } .
+$$
+
+![](images/e20432f4146cd84e1821f398dd04e03cd235015b8f630dbb3368f8435d1dab45.jpg)  
+Figure 6: The relative error of query evaluations with respect uniform, coreset, and Core Vector Machine (CVM) (Tsang et al., 2005) subsamples for the 4 data sets.
+
+Moreover, we have for the sum of sensitivities that
+
+$$
+\sum _ { i \in [ n ] } s ( p _ { i } ) \geq { \frac { { \frac { d ^ { 2 } } { 8 } } + n C } { { \frac { d ^ { 2 } } { 8 } } + C } } = \Omega \left( { \frac { d ^ { 2 } + n C } { d ^ { 2 } + C } } \right)
+$$
+
+# 8.2 PROOF OF COROLLARY 6
+
+Proof. Consider the set of points $\mathcal { P }$ from the proof of Lemma 5 and note that
+
+$$
+n = { \binom { d } { d / 2 } } \geq { \frac { 2 ^ { d } ( 1 - 1 / d ) } { \sqrt { \pi ( d / 2 ) } } } \geq { \frac { 2 ^ { d } } { \sqrt { d } } } = \Omega ( 2 ^ { d } / { \sqrt { d } } ) .
+$$
+
+# 8.3 PROOF OF LEMMA 7
+
+Proof. Consider any arbitrary point $p _ { i } ~ \in ~ \mathcal { P }$ and let $p \ = \ x _ { i } y _ { i }$ for brevity when the point $p _ { i } ~ =$ $( x _ { i } , y _ { i } )$ is clear from the context. We proceed to bound $s ( p _ { i } ) / u ( p _ { i } )$ by first leveraging the Lipschitz
+
+continuity of hinge loss and convexity of $f$
+
+Lipschitz Continuity
+
+$$
+\begin{array} { r l } { \frac { \delta ( p _ { k } ) } { n ( p _ { k } ) } = } & { \operatorname* { s u p } _ { \pm ( p _ { k } , \pm \infty ) } \frac { f ( p _ { k } , \pm \infty ) } { f ( p _ { k } , \infty ) } } \\ & { \leq \operatorname* { s u p } _ { \pm ( p _ { k } , \infty ) } \frac { f ( \tilde { p } _ { k } , \infty ) + C ( k ; \tilde { p } _ { k } , - p _ { l } ) } { f ( p _ { k } , \infty ) } } \\ &  \leq \operatorname* { s u p } _ { \pm ( p _ { k } , \infty ) } \frac { \sum _ { \sigma \geq \tilde { p } _ { k } , \infty } \langle q ( \tilde { p } _ { l } , \infty ) \rangle + \frac { C [ \langle \tilde { p } _ { k } , \tilde { p } _ { \sigma } , - p \rangle ] _ { \pm } } { f ( p _ { k } , \infty ) } } \\ & { \leq \operatorname* { s u p } _ { \pm ( p _ { k } , \infty ) \in \{ 1 , \atop p ( p _ { k } , \infty ) \} } \frac { ( f ( \tilde { p } _ { k } , \infty ) + \langle \tilde { p } _ { k } , \tilde { p } _ { \sigma } , - p \rangle ] _ { \pm } } { f ( p _ { k } , \infty ) } } \\ & { = \operatorname* { s u p } _ { \pm ( p _ { k } , \infty ) } \frac { ( f ( \tilde { p } _ { k } , \infty ) + f ( \tilde { p } _ { k } , \infty ) ) - f ( \tilde { p } _ { k } ^ { \infty } , \infty ) } { ( u ( p _ { k } , \infty ) + f ( p _ { k } , \infty ) ) } + \frac { C [ \langle w , \tilde { p } _ { k } , - p \rangle ] _ { \pm } } { f ( p , \infty ) } } \\ & { = \frac { 1 } { u ( p _ { k } , \infty ) } + \operatorname* { s u p } _ { \pm ( p _ { k } , \infty ) } \frac { C [ \langle \tilde { p } _ { k } , \tilde { p } _ { \sigma } , - p \rangle ] _ { \pm } } { f ( p _ { k } , \infty ) } - \frac { f ( \tilde { p } _ { k } ^ { \infty } , \infty ) } { u ( p _ { k } , \infty ) ( f ( p , \infty ) ) } } \\ &  \leq \frac { 1 } { u ( p _ { k } ) } + \operatorname* { s u p } _ { \pm ( p _ { k } , \infty ) } \frac  C [ \langle w , \tilde { p } _ { \sigma } , 1 \rangle ( 2 u ( p ) \cdot { u } ( p _ { k } \end{array}
+$$
+
+Jensen’s Inequality
+
+where the last inequality follows from the fact that for any $w \in \mathcal { Q } , \lVert w _ { 1 : d } \rVert _ { 2 } \geq 1$ since the points are normalized, and thus,
+
+$$
+\frac { f ( \mathcal { P } _ { y _ { i } } ^ { c } , w ) } { 2 u ( \mathcal { P } _ { y _ { i } } ) } \geq \frac { \| w _ { 1 : d } \| _ { 2 } ^ { 2 } u ( \mathcal { P } _ { y _ { i } } ^ { c } ) } { 2 u ( \mathcal { P } ) u ( \mathcal { P } _ { y _ { i } } ) } \geq u ( \mathcal { P } _ { y _ { i } } ^ { c } ) / \left( 2 u ( \mathcal { P } ) \cdot u ( \mathcal { P } _ { y _ { i } } ) \right) .
+$$
+
+Now consider the expression involving the supremum from (7) and let
+
+$$
+K _ { y _ { i } } = u ( \mathcal { P } _ { y _ { i } } ^ { \mathrm { c } } ) / \left( 2 u ( \mathcal { P } ) \cdot u ( \mathcal { P } _ { y _ { i } } ) \right)
+$$
+
+be the constant independent of $w$ in the numerator, let $p _ { \Delta } = \bar { p } _ { y _ { i } } - p$ , and let $w _ { \Delta } = w - w ^ { \ast }$ for notational convenience. We observe that by $\lambda$ -strong convexity of the SVM objective function for $\lambda = 1$ , we have the inequality $f ( \mathcal { P } , w ^ { * } ) + \lambda \left\| w - w ^ { * } \right\| _ { 2 } ^ { 2 } / 2 \leq f ( \mathcal { P } , w )$ for any $w \in \mathcal { Q }$ . Thus, the expression containing the supremum from (7) is bounded by
+
+$$
+\begin{array} { r l } & { \displaystyle \operatorname* { s u p } _ { w \in \mathcal { Q } } \frac { C \left[ \left. w , \bar { p } _ { y _ { i } } - p \right. \right] _ { + } - K _ { y _ { i } } } { f ( \mathcal { P } , w ) } = \displaystyle \operatorname* { s u p } _ { w \in \mathcal { Q } } \frac { C \left[ \left. w - w ^ { * } , \bar { p } _ { y _ { i } } - p \right. + \left. w ^ { * } , \bar { p } _ { y _ { i } } - p \right. \right] _ { + } - K _ { y _ { i } } } { f ( \mathcal { P } , w ) } } \\ & { \leq \displaystyle \operatorname* { s u p } _ { w \leq \epsilon \mathcal { Q } } \frac { C \left[ \left. w _ { \Delta } , p _ { \Delta } \right. + \left. w ^ { * } , p _ { \Delta } \right. \right] _ { + } - K _ { y _ { i } } } { f ( \mathcal { P } , w ^ { * } ) + \lambda \left\| w _ { \Delta } \right\| _ { 2 } ^ { 2 } / 2 } } \\ & { \leq \displaystyle \operatorname* { s u p } _ { w \Delta \in \mathcal { Q } } \frac { \left[ \left. w _ { \Delta } , p _ { \Delta } \right. + a \right] _ { + } + b } { c \left\| w _ { \Delta } \right\| _ { 2 } ^ { 2 } + d } , } \end{array}
+$$
+
+where $a = \langle w ^ { * } , p _ { \Delta } \rangle$ , $b = - K _ { y _ { i } } / C$ , $c = 1 / ( 2 C )$ , and $d = f ( P , w ^ { * } ) / C$ are constants independent of $w _ { \Delta }$ . Analytical optimization based on the gradient of the term above yields the optimal solution, $\begin{array} { r } { w _ { \Delta } ^ { * } = \frac { p _ { \Delta } } { 2 c z } } \end{array}$ , where
+
+$$
+z = \frac { \left. w _ { \Delta } ^ { * } , p _ { \Delta } \right. + a + b } { c \left\| w _ { \Delta } ^ { * } \right\| _ { 2 } ^ { 2 } + d } .
+$$
+
+We resolve the interdependency on $w _ { \Delta } ^ { \ast }$ by observing that
+
+$$
+\langle w _ { \Delta } ^ { * } , p _ { \Delta } \rangle = \Big \langle \frac { p _ { \Delta } } { 2 c z } , p _ { \Delta } \Big \rangle = \frac { \| p _ { \Delta } \| _ { 2 } ^ { 2 } } { 2 c z } \mathrm { a n d } \| w _ { \Delta } ^ { * } \| _ { 2 } ^ { 2 } = \langle w _ { \Delta } ^ { * } , w _ { \Delta } ^ { * } \rangle = \frac { \| p _ { \Delta } \| _ { 2 } ^ { 2 } } { ( 2 c z ) ^ { 2 } } ,
+$$
+
+which implies that $\| w _ { \Delta } ^ { * } \| _ { 2 } ^ { 2 } = \langle w _ { \Delta } ^ { * } , p _ { \Delta } \rangle / ( 2 c z )$ . Putting it all together, we obtain
+
+$$
+\begin{array} { l } { \displaystyle z \leq \frac { \sqrt { ( a + b ) ^ { 2 } + \frac { d \| p _ { \Delta } \| _ { 2 } ^ { 2 } } { c } + a + b } } { 2 d } } \\ { \displaystyle \quad = \frac { C } { 2 f ( \mathcal { P } , w ^ { * } ) } \left( \sqrt { \left( \langle w ^ { * } , p _ { \Delta } \rangle - K _ { y _ { i } } / C \right) ^ { 2 } + 2 f ( \mathcal { P } , w ^ { * } ) \left\| p _ { \Delta } \right\| _ { 2 } ^ { 2 } } + \langle w ^ { * } , p _ { \Delta } \rangle - K _ { y _ { i } } / C \right) , } \end{array}
+$$
+
+and the sensitivity bound follows.
+
+# 8.4 PROOF OF LEMMA 8
+
+Proof. Let $\mathcal { P } _ { + } = \mathcal { P } _ { 1 } \subset \mathcal { P }$ and $\mathcal { P } _ { - } = \mathcal { P } \backslash \mathcal { P } _ { 1 }$ denote the set of points with positive and negative labels respectively and let $K _ { + }$ and $K _ { - }$ denote the corresponding constants defined by (8). Let $\bar { p } _ { + }$ and $\bar { p } _ { - }$ denote the weighted mean of the positive and labeled points respectively, and for any $p _ { i } \in \mathcal { P } _ { + }$ let $p _ { \Delta _ { i } } ^ { + } = \bar { p } _ { + } - p _ { i }$ and $p _ { \Delta _ { i } } ^ { - } = \bar { p } _ { - } - p _ { i }$ .
+
+Since the sensitivity can be decomposed into sum over the two disjoint sets, i.e., $S ( { \mathcal { P } } ) ~ =$ $\begin{array} { r } { \sum _ { p \in \mathcal { P } } s ( p ) = \sum _ { p \in \mathcal { P } _ { 1 } } s ( p ) + \sum _ { p \in \mathcal { P } _ { - } } s ( p ) = S ( \mathcal { P } _ { 1 } ) + S ( \mathcal { P } _ { - } ) } \end{array}$ , we consider first bounding $S ( \mathcal { P } _ { 1 } )$ . Invoking Lemma 7 yields
+
+$$
+\begin{array} { l } { { \displaystyle \dot { \gamma } ( \mathcal { P } _ { 1 } ) \le 1 + \sum _ { p _ { i } \in \mathcal { P } _ { + } } \frac { C u ( p _ { i } ) } { 2 f ( \mathcal { P } , w ^ { * } ) } \left( \sqrt { \left( \langle w ^ { * } , p _ { \Delta _ { i } } ^ { + } \rangle - K _ { + } / C \right) ^ { 2 } + 2 f ( \mathcal { P } , w ^ { * } ) \left\| p _ { \Delta _ { i } } ^ { + } \right\| _ { 2 } ^ { 2 } } + \langle w ^ { * } , p _ { \Delta _ { i } } ^ { + } \rangle - K _ { + } ( C _ { + } , \mathcal { P } _ { + } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } , \mathcal { P } _ { - } \right) \right) } }  \\ { { \displaystyle \le 1 + \sum _ { p _ { i } \in \mathcal { P } _ { + } } \frac { C u ( p _ { i } ) } { 2 f ( \mathcal { P } , w ^ { * } ) } \left( \sqrt { \left( \langle w ^ { * } , p _ { \Delta _ { i } } ^ { + } \rangle - K _ { + } / C \right) ^ { 2 } + 2 f ( \mathcal { P } , w ^ { * } ) \left\| p _ { \Delta _ { i } } ^ { + } \right\| _ { 2 } ^ { 2 } } \right) } } \\ { { \displaystyle \le 1 + \frac { C } { f ( \mathcal { P } , w ^ { * } ) } \sum _ { p _ { i } \in \mathcal { P } _ { + } } u ( p _ { i } ) \left( \left\| p _ { \Delta _ { i } } ^ { + } \right\| _ { 2 } \sqrt { f ( \mathcal { P } , w ^ { * } ) } \right) } } \\   \displaystyle = 1 + \frac { C }  \sqrt { f ( \mathcal { P } , w ^ { * } ) } \sum _ { p _ { i } \in \mathcal { P } _ { + } } u ( p _ { i } ) \left\| p _  \Delta _  \end{array}
+$$
+
+where the second equality follows by the definition of $K _ { + }$ and the fact that
+
+$$
+\begin{array} { r l } { \displaystyle \sum _ { p _ { i } \in \mathcal { P } _ { + } } u ( p _ { i } ) \langle w ^ { * } , p _ { \Delta _ { i } } ^ { + } \rangle = \displaystyle \sum _ { p _ { i } \in \mathcal { P } _ { + } } u ( p _ { i } ) \langle w ^ { * } , \bar { p } _ { + } \rangle - \displaystyle \sum _ { p _ { i } \in \mathcal { P } _ { + } } u ( p _ { i } ) \langle w ^ { * } , p _ { i } \rangle } & { } \\ { \displaystyle } & { = \langle w ^ { * } , \bar { p } _ { + } \rangle \displaystyle \sum _ { p _ { i } \in \mathcal { P } _ { + } } u ( p _ { i } ) - \displaystyle \sum _ { p _ { i } \in \mathcal { P } _ { + } } u ( p _ { i } ) \langle w ^ { * } , p _ { i } \rangle = 0 , } \end{array}
+$$
+
+and the third by noting that $\left( \langle w ^ { * } , p _ { \Delta _ { i } } ^ { + } \rangle - K _ { + } / C \right) ^ { 2 } \leq 2 f ( \mathcal { P } , w ^ { * } ) \left\| p _ { \Delta _ { i } } ^ { + } \right\| _ { 2 } ^ { 2 }$ since by Cauchy-Schwarz and definition of $f ( \mathcal { P } , w ^ { * } )$ we have
+
+$$
+\begin{array} { r } { \langle w ^ { * } , p _ { \Delta _ { i } } ^ { + } \rangle - K _ { + } / C \leq \| w ^ { * } \| _ { 2 } \left\| p _ { \Delta _ { i } } ^ { + } \right\| _ { 2 } \leq \sqrt { 2 f ( \mathcal { P } , w ^ { * } ) } \left\| p _ { \Delta _ { i } } ^ { + } \right\| _ { 2 } . } \end{array}
+$$
+
+Using the same argument as above, an analogous bound holds for $S ( \mathcal P _ { - } )$ , thus we have
+
+$$
+\begin{array} { l } { { S ( \mathcal { P } ) \leq 2 + \displaystyle \frac { C } { \sqrt { f ( \mathcal { P } , w ^ { * } ) } } \left( \displaystyle \sum _ { p _ { i } \in \mathcal { P } _ { 1 } } u ( p _ { i } ) \left\| p _ { \Delta _ { i } } ^ { + } \right\| _ { 2 } + \displaystyle \sum _ { p _ { i } \in \mathcal { P } _ { - } } u ( p _ { i } ) \left\| p _ { \Delta _ { i } } ^ { - } \right\| _ { 2 } \right) } } \\ { { \mathrm { ~ } = 2 + \displaystyle \frac { C \left( \operatorname { V a r } ( \mathcal { P } _ { + } ) + \operatorname { V a r } ( \mathcal { P } _ { - } ) \right) } { \sqrt { f ( \mathcal { P } , w ^ { * } ) } } = t . } } \end{array}
+$$
+
+# 8.5 PROOF OF THEOREM 9
+
+Proof. By Lemma 8 and Theorem 5.5 of Braverman et al. (2016) we have that the coreset constructed by our algorithm is an $\varepsilon$ -coreset with probability at least $1 - \delta$ if
+
+$$
+| S | \geq \Omega \left( \frac { t } { \varepsilon ^ { 2 } } \big ( d \log t + \log ( 1 / \delta ) \big ) \right) ,
+$$
+
+where we used the fact that the VC dimension of a separating hyperplane in the case of a linear kernel is bounded $\dim ( { \mathcal { F } } ) \leq d + 1 = { \mathcal { O } } ( d )$ (Vapnik $\&$ Vapnik, 1998). Moreover, note that the computation time of our algorithm is dominated by computing the optimal solution of the SVM problem using interior-point Method which takes $\dot { \mathcal { O } ( d ^ { 3 } L ) } = \mathcal { O } \bar { ( n ^ { 3 } ) }$ time (Nesterov & Nemirovskii, 1994), where $L$ is the bit length of the input data. □
+
+# 8.6 PROOF OF COROLLARY 10
+
+Proof. By theorem 9, $( \boldsymbol { \mathcal { S } } , \boldsymbol { v } )$ is an $\varepsilon$ -coreset for $( \mathcal { P } , u )$ with probability at least $1 - \delta$ , thus we have
+
+$$
+\begin{array} { l } { \displaystyle f \big ( ( \mathcal { P } , u ) , w _ { \mathcal { P } } ^ { * } \big ) \leq f \big ( ( \mathcal { P } , u ) , w _ { \mathcal { S } } ^ { * } \big ) \leq \frac { f ( ( \mathcal { S } , v ) , w _ { \mathcal { S } } ^ { * } ) } { 1 - \varepsilon } \leq \frac { ( 1 + \varepsilon ) f ( ( \mathcal { P } , u ) , w _ { \mathcal { P } } ^ { * } ) } { 1 - \varepsilon } } \\ { \leq ( 1 + 4 \varepsilon ) f ( ( \mathcal { P } , u ) , w _ { \mathcal { P } } ^ { * } ) . } \end{array}
+$$
+
+# 8.7 PROOF OF LEMMA 11
+
+Proof. The proof is almost identical to that of Lemma 7, thus we use the same techniques to arrive at the following inequality with $\hat { w }$ instead of $w ^ { * }$ and with $w _ { \Delta } = w - \hat { w }$ :
+
+$$
+\begin{array} { r l } & { \displaystyle \frac { s ( p _ { i } ) } { u ( p _ { i } ) } = \displaystyle \operatorname* { s u p } _ { w \in Q ( \mathcal { P } ) } \frac { f ( p _ { i } , w ) } { f ( \mathcal { P } , w ) } } \\ & { \qquad \leq \displaystyle \frac { 1 } { u ( \mathcal { P } _ { y _ { i } } ) } + \operatorname* { s u p } _ { w \in \mathcal { Q } } \frac { C \left[ \langle w , \bar { p } _ { y _ { i } } - p \rangle \right] _ { + } - u ( \mathcal { P } _ { y _ { i } } ^ { c } ) / ( 2 u ( \mathcal { P } ) \cdot u ( \mathcal { P } _ { y _ { i } } ) ) } { f ( \mathcal { P } , w ) } } \\ & { \qquad \leq \displaystyle \frac { 1 } { u ( \mathcal { P } _ { y _ { i } } ) } + \displaystyle \operatorname* { s u p } _ { w \Delta \in \mathcal { Q } } \frac { C \left[ \langle w _ { \Delta } , p _ { \Delta } \rangle + \langle \hat { w } , p _ { \Delta } \rangle \right] _ { + } - K _ { y _ { i } } } { f ( \mathcal { P } , w ^ { * } ) + \| w - w ^ { * } \| _ { 2 } ^ { 2 } / 2 } . } \end{array}
+$$
+
+Now, consider the supremum term and note that (i) $f ( \mathcal { P } , w ^ { * } ) \ge f ( \mathcal { P } , \hat { w } ) - \xi$ by definition of $\hat { w }$ and (ii) $\left. w - w ^ { * } \right. _ { 2 } ^ { 2 } / 2 \geq \left. w - \hat { w } \right. _ { 2 } ^ { 2 } / 4 - \xi$ , since by the Cauchy-Schwarz inequality we have
+
+$$
+\begin{array} { r l } & { \left\| w - \hat { w } \right\| _ { 2 } ^ { 2 } \leq 2 \left( \left\| w - w ^ { * } \right\| _ { 2 } ^ { 2 } + \left\| w ^ { * } - \hat { w } \right\| _ { 2 } ^ { 2 } \right) } \\ & { \qquad \leq 2 \left\| w - w ^ { * } \right\| _ { 2 } ^ { 2 } + 4 \xi , } \end{array}
+$$
+
+where the last inequality follows by strong convexity of $f$ and by definition of our approximation:
+
+$$
+\frac { \left\| \hat { w } - w ^ { * } \right\| _ { 2 } ^ { 2 } } { 2 } \leq f ( \mathcal { P } , \hat { w } ) - f ( \mathcal { P } , w ^ { * } ) \leq \xi .
+$$
+
+Combining (i) and (ii) yields for the supremum term
+
+$$
+\begin{array} { r l } & { \displaystyle \operatorname* { s u p } _ { w _ { \Delta } \in { \mathcal Q } } \frac { C \left[ \left. w _ { \Delta } , p _ { \Delta } \right. + \left. \hat { w } , p _ { \Delta } \right. \right] _ { + } - K _ { y _ { i } } } { f ( { \mathcal P } , w ^ { * } ) + \| w - w ^ { * } \| _ { 2 } ^ { 2 } / 2 } } \\ & { \leq \displaystyle \operatorname* { s u p } _ { w _ { \Delta } \in { \mathcal Q } } \frac { C \left[ \left. w _ { \Delta } , p _ { \Delta } \right. + \left. \hat { w } , p _ { \Delta } \right. \right] _ { + } - K _ { y _ { i } } } { f ( { \mathcal P } , \hat { w } ) - 2 \xi + \| w _ { \Delta } \| _ { 2 } ^ { 2 } / 4 } } \\ & { \leq \displaystyle \operatorname* { s u p } _ { w _ { \Delta } \in { \mathcal Q } } \frac { \left[ \left. w _ { \Delta } , p _ { \Delta } \right. + a \right] _ { + } + b } { c \| w _ { \Delta } \| _ { 2 } ^ { 2 } + d } , } \end{array}
+$$
+
+where $a = \langle \hat { w } , p _ { \Delta } \rangle$ , $b = - K _ { y _ { i } } / C$ , $c = 1 / ( 4 C )$ , and $d = \left( f ( \mathcal { P } , \hat { w } ) - 2 \xi \right) / C$ are constants independent of $w _ { \Delta }$ .
+
+This is the exact same expression as in the proof of Lemma 7, with the exception of slightly different values for the constants above. Thus, analytical optimization yields the same optimal solution as before and thus we have
+
+$$
+\frac { s ( p _ { i } ) } { u ( p _ { i } ) } \leq \frac { 1 } { u ( \mathcal { P } _ { y _ { i } } ) } + \frac { \sqrt { ( a + b ) ^ { 2 } + \frac { d \| p _ { \Delta } \| _ { 2 } ^ { 2 } } { c } } + a + b } { 2 d } ,
+$$
+
+and the lemma follows.
+
+# REFERENCES
+
+Pankaj K Agarwal and R Sharathkumar. Streaming algorithms for extent problems in high dimensions. In Proceedings of the twenty-first annual ACM-SIAM symposium on Discrete Algorithms, pp. 1481–1489. Society for Industrial and Applied Mathematics, 2010.
+
+Pankaj K Agarwal, Sariel Har-Peled, and Kasturi R Varadarajan. Geometric approximation via coresets. Combinatorial and computational geometry, 52:1–30, 2005.
+
+Olivier Bachem, Mario Lucic, and Andreas Krause. Practical coreset constructions for machine learning. arXiv preprint arXiv:1703.06476, 2017.
+
+Vladimir Braverman, Dan Feldman, and Harry Lang. New frameworks for offline and streaming coreset constructions. arXiv preprint arXiv:1612.00889, 2016.
+
+Kenneth L Clarkson. Coresets, sparse greedy approximation, and the frank-wolfe algorithm. ACM Transactions on Algorithms (TALG), 6(4):63, 2010.
+
+Kenneth L Clarkson, Elad Hazan, and David P Woodruff. Sublinear optimization for machine learning. Journal of the ACM (JACM), 59(5):23, 2012.
+
+Dan Feldman and Michael Langberg. A unified framework for approximating and clustering data. In Proceedings of the forty-third annual ACM symposium on Theory of computing, pp. 569–578. ACM, 2011.
+
+Dan Feldman, Matthew Faulkner, and Andreas Krause. Scalable training of mixture models via coresets. In Advances in neural information processing systems, pp. 2142–2150, 2011.
+
+Bernd Gartner and Martin Jaggi. Coresets for polytope distance. In ¨ Proceedings of the twenty-fifth annual symposium on Computational geometry, pp. 33–42. ACM, 2009.
+
+Sariel Har-Peled and Soham Mazumdar. On coresets for k-means and k-median clustering. In Proceedings of the thirty-sixth annual ACM symposium on Theory of computing, pp. 291–300. ACM, 2004.
+
+Sariel Har-Peled, Dan Roth, and Dav Zimak. Maximum margin coresets for active and noise tolerant learning. In IJCAI, pp. 836–841, 2007.
+
+Elad Hazan, Tomer Koren, and Nati Srebro. Beating sgd: Learning svms in sublinear time. In Advances in Neural Information Processing Systems, pp. 1233–1241, 2011.
+
+Jonathan H Huggins, Trevor Campbell, and Tamara Broderick. Coresets for scalable bayesian logistic regression. arXiv preprint arXiv:1605.06423, 2016.
+
+Thorsten Joachims. Training linear svms in linear time. In Proceedings of the 12th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 217–226. ACM, 2006.
+
+Michael Langberg and Leonard J Schulman. Universal $\varepsilon$ -approximators for integrals. In Proceedings of the twenty-first annual ACM-SIAM symposium on Discrete Algorithms, pp. 598–607. SIAM, 2010.
+
+M. Lichman. UCI machine learning repository, 2013. URL http://archive.ics.uci.edu/ ml.
+
+Gaelle Loosli and St ¨ ephane Canu. Comments on the “Core Vector Machines: Fast SVM Training ´ on Very Large Data Sets. Journal of Machine Learning Research, 8(Feb):291–301, 2007.
+
+Mario Lucic, Olivier Bachem, and Andreas Krause. Linear-time outlier detection via sensitivity. arXiv preprint arXiv:1605.00519, 2016.
+
+Mario Lucic, Matthew Faulkner, Andreas Krause, and Dan Feldman. Training mixture models at scale via coresets. arXiv preprint arXiv:1703.08110, 2017.
+
+Manu Nandan, Pramod P Khargonekar, and Sachin S Talathi. Fast svm training using approximate extreme points. Journal of Machine Learning Research, 15(1):59–98, 2014.
+
+Yurii Nesterov and Arkadii Nemirovskii. Interior-point polynomial algorithms in convex programming. SIAM, 1994.
+
+Piyush Rai, Hal Daume III, and Suresh Venkatasubramanian. Streamed learning: one-pass svms. ´ arXiv preprint arXiv:0908.0572, 2009.
+
+Shai Shalev-Shwartz, Yoram Singer, Nathan Srebro, and Andrew Cotter. Pegasos: Primal estimated sub-gradient solver for svm. Mathematical programming, 127(1):3–30, 2011.
+
+Ivor W Tsang, James T Kwok, and Pak-Ming Cheung. Core vector machines: Fast svm training on very large data sets. Journal of Machine Learning Research, 6(Apr):363–392, 2005.
+
+Vladimir Naumovich Vapnik and Vlamimir Vapnik. Statistical learning theory, volume 1. Wiley New York, 1998.
+
+Jiyan Yang, Yin-Lam Chow, Christopher Re, and Michael W Mahoney. Weighted sgd for ´ \ell p regression with randomized preconditioning. arXiv preprint arXiv:1502.03571, 2017.

parse/train/x_n34KpwAvI/x_n34KpwAvI.md

@@ -0,0 +1,262 @@
+# SIMILAR: Submodular Information Measures Based Active Learning In Realistic Scenarios
+
+Suraj Kothawade University of Texas at Dallas suraj.kothawade@utdallas.edu
+
+Nathan Beck University of Texas at Dallas nathan.beck@utdallas.edu
+
+Krishnateja Killamsetty University of Texas at Dallas krishnateja.killamsetty@utdallas.edu
+
+Rishabh Iyer University of Texas at Dallas rishabh.iyer@utdallas.edu
+
+# Abstract
+
+Active learning has proven to be useful for minimizing labeling costs by selecting the most informative samples. However, existing active learning methods do not work well in realistic scenarios such as imbalance or rare classes, out-of-distribution data in the unlabeled set, and redundancy. In this work, we propose SIMILAR (Submodular Information Measures based actIve LeARning), a unified active learning framework using recently proposed submodular information measures (SIM) as acquisition functions. We argue that SIMILAR not only works in standard active learning but also easily extends to the realistic settings considered above and acts as a one-stop solution for active learning that is scalable to large real-world datasets. Empirically, we show that SIMILAR significantly outperforms existing active learning algorithms by as much as $\approx 5 \% - \mathrm { \bar { 1 } 8 \% }$ in the case of rare classes and $\approx 5 \% - 1 \mathrm { \bar { 0 } \% }$ in the case of out-of-distribution data on several image classification tasks like CIFAR-10, MNIST, and ImageNet. SIMILAR is available as a part of the DISTIL toolkit: https://github.com/decile-team/distil.
+
+# 1 Introduction
+
+Deep neural networks (DNNs) have had a lot of success in a wide variety of domains. However, they require large labeled datasets which are often taxing, time-consuming, and expensive to obtain. Active learning (AL) [12, 13, 39, 3, 9] is a promising approach to solve this problem. It aims to select the most informative data points from an unlabeled dataset to be labeled in an adaptive manner with a human in the loop. The goal of AL is to achieve maximum accuracy of the model while minimizing the number of data points required to be labeled.
+
+Current AL methods have been tested in relatively simple, clean, and balanced datasets. However, real-world datasets are not clean and have a number of characteristics that makes learning from them challenging [10, 46, 47, 38, 1, 8]. Firstly, these real-world datasets are im
+
+![](images/a48dfbee6ce2308ced0121a6e7825fa32b4f4a129cb71e47debd6343efc58b1c.jpg)  
+Figure 1: Motivating scenarios for realistic active learning: (a) rare classes: digits 5 and 8 are rare; (b) redundancy: digits 0 and 1 are redundant; (c) out-of-distribution (OOD): letters A, R, B, F in digit classification.
+
+balanced, and some classes are very rare (e.g., Fig 1(a)). Examples of this imbalance are medical imaging domains where the cancerous images are rare. Secondly, real-world data has a lot of redundancy (e.g., Fig 1(b)). This redundancy is more prominent in datasets that are created by sampling frames from videos (e.g., footage from a car driving on a freeway or surveillance camera footage). Thirdly, it is common to have out-of-distribution (OOD) (e.g., Fig 1(c)) data, where some part of the unlabeled data is not of concern to the task at hand. Given the amount of unlabeled data, it is not realistic to assume that these datasets can be cleaned manually; hence, it is the need of the hour to have active learning methods that are robust to such scenarios. We show that current AL approaches (including the state-of-the-art approach BADGE [3]) do not work well in the presence of the dataset biases described above. In this work, we address the following question: Can a machine learning model be trained using a single unified active learning framework that works for a broad spectrum of realistic scenarios? As a solution, we propose SIMILAR1, a unified active learning framework which enables active learning for many realistic scenarios like rare classes, out-of-distribution (OOD) data, and redundancy.
+
+# 1.1 Related Work
+
+Active learning has enabled efficient training of complex deep neural networks by decreasing labeling costs. The most commonly used approach is to select the most uncertain items. Examples of uncertainty strategies include ENTROPY [41], LEAST CONFIDENCE [44], and MARGIN [37]. One challenge of this approach is that all the samples within a batch can be potentially similar even though they are uncertain. To overcome this problem in batch active learning, many recent works have attempted to select diverse yet informative data points. [45, 22] propose a simple approach: Filter a set of points using uncertainty sampling and then select a diverse subset from the filtered set. [40] propose CORESET, which forms core-sets using greedy $k$ -center clustering while maintaining the geometric arrangement. BADGE [3], another recent approach, proposes to select data points corresponding to high-magnitude, diverse hypothesized gradients by using ${ \mathrm { K } } { \mathrm { - } } { \mathrm { M E A N S } } { + + }$ [2] initialization to distance from previously selected data points in the batch. Most existing AL approaches fail to ensure diversity across AL selection rounds and do not perform as well when there is a lot of redundancy. Sinha et al. [42] used a variational autoencoder (VAE) [25] to learn a feature space and an adversarial network [32] to distinguish between labeled and unlabeled data points. However, their approach is computationally expensive and requires extensive hyperparameter tuning. Similarly, BATCHBALD [26] does not scale to larger batch sizes since their method would need a large number of Monte Carlo dropout samples to obtain a significant mutual information. Such limitations reduce the scope of applying these methods to realistic settings.
+
+Closely related to our work are two recently proposed works. The first is GLISTER-ACTIVE [24], which formulates the AL acquisition function by maximizing the log-likelihood on a held-out validation set. This validation set could consist of examples from the rare classes or in-distribution examples. The second approach is the work of Gudovskiy et al. [15], who study AL for biased datasets using a self-supervised FISHER kernel and pseudo-label estimators. They address this problem by explicitly minimizing the KL divergence between training and validation sets via maximizing the FISHER kernel. Although their method shows promising results, they make multiple unrealistic assumptions: a) They use a large labeled validation set, and b) they use feature representations from a model pretrained using unsupervised learning on a balanced unlabeled dataset. In this work, we compare against both GLISTER-ACTIVE [24] and FISHER [15] approaches in the more realistic setting of a small held-out validation set (smaller than the seed labeled set) and an imbalanced unlabeled set. Another work proposed a discrete optimization method for $k$ -NN-type algorithms in the domain shift setting [6]. However, their approach is limited to $k$ -NNs.
+
+This work utilizes submodular information measures (SIM) by [19] and their extensions by [23]. SIMs encompass submodular conditional mutual information (SCMI), which can then be used to derive submodular mutual information (SMI); submodular conditional gain (SCG); and submodular functions (SF). We discuss these functions in detail in Sec. 2. [23] also studies these functions on the closely related problem of targeted data selection.
+
+# 1.2 Our Contributions
+
+The following are our main contributions: 1) Given the limitations of existing approaches in handling active learning in the real world, we propose SIMILAR (Sec. 3), a unified active learning framework that can serve as a comprehensive solution to multiple realistic scenarios. 2) We treat SIM as a common umbrella for realistic active learning and study the effect of different function instantiations offered under SIM for various realistic scenarios. 3) SIMILAR not only handles standard active learning but also extends to a wide range of settings which appear in the real world such as rare classes, out-of-distribution (OOD) data, and datasets with a lot of redundancy. Finally, 4) we empirically demonstrate the effectiveness of SMI-based measures for image classification (Sec. 4) in a number of realistic data settings including imbalanced, out-of-distribution, and redundant data. Specifically, in the case of imbalanced and OOD data, we show that SIMILAR achieves improvements of more than 5 to $10 \%$ on several image classification datasets.
+
+# 2 Background
+
+In this section, we enumerate the different submodular functions that are covered under SIM and the relationships between them.
+
+Submodular Functions. We let $\mathcal { U }$ denote the unlabeled set of $n$ data points $\mathcal { U } = \{ 1 , 2 , 3 , . . . , n \}$ and a set function $f : 2 ^ { \mathcal { U } } \to \mathbb { R }$ . Formally, a function $f$ is submodular [14] if for $x \in \mathcal { U }$ , $f ( { \mathcal { A } } \cup { \mathcal { x } } ) - f ( { \mathcal { A } } ) \geq$ $f ( B \cup x ) - { \overline { { f ( B ) } } }$ , $\forall { \mathcal { A } } \subseteq B \subseteq { \mathcal { U } }$ and $x \notin B$ . For a set ${ \mathcal { A } } \subseteq { \mathcal { U } }$ , $f ( A )$ provides a real-valued score for $\mathcal { A }$ . In the context of batch active learning, this is the score of an acquisition function $f$ on batch $\mathcal { A }$ . Submodularity is particularly appealing because it naturally occurs in real world applications [43, 4, 5, 20] and also admits a constant factor $1 - { \frac { 1 } { e } }$ [34] for cardinality constraint maximization. Additionally, variants of the greedy algorithm maximize a submodular function in near-linear time [33].
+
+Submodular Mutual Information (SMI). Given sets ${ \mathcal { A } } , { \mathcal { Q } } \subseteq { \mathcal { U } }$ , the SMI [16, 19] is defined as $I _ { f } ( A ; \mathcal { Q } ) = f ( A ) + f ( \mathcal { Q } ) - f ( A \cup \mathcal { Q } )$ . Intuitively, SMI models the similarity between $\mathcal { Q }$ and $\mathcal { A }$ and maximizing SMI will select points similar to $\mathcal { Q }$ while being diverse. $\mathcal { Q }$ here is the query set.
+
+Submodular Conditional Gain (SCG). Given sets $\mathcal { A } , \mathcal { P } \subseteq \mathcal { U }$ , the SCG $f ( A | \mathcal { P } )$ is the gain in function value by adding $\mathcal { A }$ to $\mathcal { P }$ . Thus, $f ( A | \mathcal { P } ) = f ( A \cup \mathcal { P } ) - f ( \mathcal { P } )$ [19]. Intuitively, SCG models how different $\mathcal { A }$ is from $\mathcal { P }$ , and maximizing SCG functions will select data points not similar to the points in $\mathcal { P }$ while being diverse. We refer to $\mathcal { P }$ as the conditioning set.
+
+Submodular Conditional Mutual Information (SCMI). Given sets $\mathcal { A } , \mathcal { Q } , \mathcal { P } \subseteq \mathcal { U }$ , the SCMI is defined as $I _ { f } ( { \cal { A } } ; { \cal { Q } } | { \mathcal { P } } ) = f ( { \cal { A } } \cup { \mathcal { P } } ) + f ( { \cal { Q } } \cup { \mathcal { P } } ) - f ( { \cal { A } } \cup { \cal { Q } } \cup { \mathcal { P } } ) - f ( { \mathcal { P } } )$ . Intuitively, SCMI jointly models the similarity between $\mathcal { A }$ and $\mathcal { Q }$ and their dissimilarity with $\mathcal { P }$ .
+
+Relationship between SIM The relationship between the above measures is the key component that unifies our AL framework [19, 23]. The unification comes from the rich modeling capacity of SCMI: $I _ { f } ( { \cal { A } } ; \mathcal { Q } | \mathcal { P } )$ where $\mathcal { Q } , \mathcal { P } \subseteq \mathcal { U }$ . This facilitates a single acquisition function that can be applied to multiple scenarios. Concretely, the submodular function $f$ can be obtained
+
+<table><tr><td>Function</td><td>Setting</td><td>Realistic Scenario</td></tr><tr><td>Submodular</td><td>Q←U,P←0</td><td>Standard AL</td></tr><tr><td>SMI</td><td>Q↑ Q,P←0</td><td>Imbalance,OOD</td></tr><tr><td>SCG</td><td>Q←,P←p</td><td>Redundancy</td></tr><tr><td>SCMI</td><td>Q←Q,P←P</td><td>0OD</td></tr></table>
+
+Table 1: Relationship between SIM and their applications to realistic scenarios by choices of $\mathcal { Q }$ and $\mathcal { P }$ .
+
+by setting $\mathcal { Q }  \mathcal { U }$ and $\mathcal { P }  \emptyset$ . Next, the SMI can be obtained by setting $\mathcal { Q }  \mathcal { Q }$ and $\mathcal { P }  \emptyset$ , while we obtain SCG by setting $\mathcal { Q }  \emptyset$ , $\mathcal { P }  \mathcal { P }$ . We summarize the relationships between SIM in Tab. 1.
+
+Instantiations of SIM. The formulations for Facility Location (FL), Graph Cut (GC) and Log Determinant (LOGDET) are as in [19, 23] and we adapt them as acquisition functions for batch active learning. We use two variants for FL: FLQMI, which models pairwise similarities of only the query set $\mathcal { Q }$ to the unlabeled dataset, and FLVMI, which additionally considers the pairwise similarities within the unlabeled dataset $\mathcal { U }$ . The SCG and SCMI expressions corresponding to $\mathrm { F L }$ are referred as FLCG and FLCMI, respectively (see row 1 in Tab. 2a and 2b). For LOGDET, we refer to the SMI, SCG and SCMI expressions as LOGDETMI, LOGDETCG and LOGDETCMI, respectively (see row 5 in Tab. 2a and row 2 in Tab. 2b). Similarly, the SMI and SCG expressions are respectively referred to as GCMI and GCCG for GC (see row 3 in Tab. 2a and 2b). For notation in Tab. 2, the pairwise similarity matrix $S$ between items in sets $\mathcal { A }$ and $\boldsymbol { B }$ is denoted as $S _ { A , B }$ . Also, we denote $S _ { i j }$ as the $( i , j )$ entry of $S$ .
+
+# 3 SIMILAR: Our Unified Active Learning Framework
+
+In this section, we propose a unified active learning framework SIMILAR, which uses SIMs to address the limitations of the current work (see Sec. 1.1). We show that SIMILAR can be effectively applied to a broad range of realistic scenarios and thus acts as one-stop solution for AL.
+
+Table 2: Instantiations of SIM. Note how the relationships in Tab. 1 can be applied to SCMI instantiations to obtain SMI and SCG instantiations.
+
+(a) Instantiations of SMI functions.
+
+<table><tr><td>SMI</td><td>If(A; Q)</td></tr><tr><td>FLVMI</td><td>E min(max Sij，max Sij） jEA jEQ</td></tr><tr><td>FLQMI</td><td>M max Sij+ ∑max Sij iEQJEA iEAJEQ</td></tr><tr><td>GCMI</td><td>2M M Sij</td></tr><tr><td>LOGDETMI</td><td>iEAjEQ log det(SA)-log det(SA- SAQS1ST.Q)</td></tr></table>
+
+(b) Instantiations of SCG and SCMI functions.   
+
+<table><tr><td>SCG</td><td>f(AP)</td></tr><tr><td>FLCG</td><td>M max(max Sij-max Sij,0) iEu jEA jEp</td></tr><tr><td>LogDetCG</td><td></td></tr><tr><td>GCCG</td><td>f(A)-2∑ Sij iEA,j∈P</td></tr></table>
+
+<table><tr><td>SCMI</td><td colspan="2">If(A; Q|P)</td></tr><tr><td>FLCMI</td><td rowspan="3">max(min(max Sij， M iEu</td><td>maxSij） maxSij，0） 一 jEA jEQ jEp -1 -1</td></tr><tr><td>LogDetCMI</td><td>spQs</td></tr><tr><td>log</td><td>det(1-sAUpSAUP,QSAUPQ)</td></tr></table>
+
+The basic idea behind our framework is to exploit the relationship between the SIMs (Tab. 1) such that it can be applied to any real-world dataset. Particularly, we use the formulation of SCMI and appropriately choose a query set $\mathcal { Q }$ and/or a conditioning set $\mathcal { P }$ depending on the scenario at hand. Towards this end, we use the inspiration from [3] where they select data points based on diverse gradients. The SIM functions (see Tab. 2) are instantiated using similarity kernels computed using pairwise similarities $S _ { i j }$ between the gradients of the current model. Specifically, we define $S _ { i j } \overset { = } \langle \nabla _ { \theta } \mathcal { H } _ { i } ( \theta ) , \nabla _ { \theta } \mathcal { H } _ { j } ( \theta ) \rangle$ , where $\mathcal { H } _ { i } ( \theta ) \doteq \mathcal { H } ( x _ { i } , y _ { i } , \theta )$ is the loss on the $i$ th data point. Similar to [45, 3], we use hypothesized labels for computing the gradients, and the corresponding similarity kernels. The hypothesized label for each data point is assigned as the class with the maximum probability. We then optimize a SCMI function:
+
+$$
+\operatorname* { m a x } _ { \scriptstyle \mathscr { A } \subseteq \mathscr { U } , | \mathscr { A } | \leq B } I _ { f } ( \mathscr { A } ; \mathscr { Q } | \mathscr { P } )
+$$
+
+with appropriate choices of query set $\mathcal { Q }$ and conditioning set $\mathcal { P }$ . In the context of batch active learning, $\mathcal { A }$ is the batch and $B$ is the budget (batch size in AL). We present our unified AL framework in Algorithm 1 and illustrate the choices of query and conditioning set for realistic scenarios in Fig. 2.
+
+# Algorithm 1 SIMILAR: Unified AL Framework
+
+Require: Initial Labeled set of data points: $\mathcal { L }$ , large unlabeled dataset: $\mathcal { U }$ , Loss function $\mathcal { H }$ for learning model $\mathcal { M }$ , batch size: $B$ , number of selection rounds: $N$   
+1: for selection round $i = 1 : N$ do   
+2: Train model $\mathcal { M }$ with loss $\mathcal { H }$ on the current labeled set $\mathcal { L }$ and obtain parameters $\theta$   
+3: Using model parameters $\theta _ { i }$ , compute gradients using hypothesized labels $\{ \nabla _ { \boldsymbol { \theta } } \bar { \mathcal { H } } ( x _ { j } , \hat { y _ { j } } , \boldsymbol { \theta } ) , \bar { \forall } j \in \mathcal { U } \}$ and obtain a similarity matrix $X$ .   
+4: Instantiate a submodular function $f$ based on $X$ .   
+5: $\begin{array} { r } { \mathcal { A } _ { i }  \operatorname { a r g m a x } _ { \boldsymbol { A } \subseteq \mathcal { U } , | \boldsymbol { A } | \leq B } I _ { f } ( \boldsymbol { A } ; \boldsymbol { \mathcal { Q } } | \mathcal { P } ) } \end{array}$ (Optimize SCMI with an appropriate choice of $\mathcal { Q }$ and $\mathcal { P }$ , see Tab. 1)   
+6: Get labels $L ( \mathcal { A } _ { i } )$ for batch $\mathbf { \mathcal { A } } _ { i }$ and $\mathcal { L }  \mathcal { L } \cup L ( A _ { i } ) , \mathcal { U }  \mathcal { U } - A _ { i }$   
+7: end for   
+8: Return trained model $\mathcal { M }$ and parameters $\theta$ .
+
+In the scenarios below, we will discuss how this paradigm can provide a unified view of active learning, handle aspects like standard active learning (Sec. 3.1), rare classes and imbalance (Sec. 3.2), redundancy (Sec. 3.3) and, OOD/outliers in the unlabeled data (Sec. 3.4).
+
+# 3.1 Standard Active Learning
+
+We refer to standard active learning for ideal scenarios when there is no imbalance, redundancy or OOD data in the unlabeled dataset. In such cases, there is no requirement for having a query set and conditioning set. Hence, given a SCMI function $I _ { f } ( { \mathcal { A } } ; { \mathcal { Q } } | { \mathcal { P } } )$ , we get $I _ { f } ( { \mathcal { A } } ; { \mathcal { Q } } | { \mathcal { P } } ) = { \bar { f } } ( { \bar { \mathcal { A } } } )$ by setting $\mathcal { Q }  \mathcal { U }$ (the unlabeled dataset) and $\mathcal { P }  \emptyset$ . In a nutshell, the standard diversified active learning setting can be seen as a special case of our proposed unified AL framework (Equ. (1)) by choosing ${ \mathcal { Q } } , { \mathcal { P } }$ as above. Note that this approach is very similar and closely related to BADGE [3], where the authors also choose points based on diverse gradients. Furthermore, the authors discuss the use of Determinantal Point Processes (DPP) [28] for sampling, and this is very similar to maximizing log-determinants. In the supplementary paper, we compare the choice of different submodular functions for AL.
+
+# 3.2 Rare Classes
+
+A very common and naturally occurring scenario is that of imbalanced data. This imbalance is because some classes or attributes are naturally more frequently occurring than others in the realworld. For example, in a self-driving car application, there may be very few images of pedestrians at night on highways, or cyclists at night. Another example is medical imaging, where there are many rare yet important diseases (e.g., various forms of cancers), and it is often the case that non-cancerous images are much more than compared to the cancerous ones. While such classes are rare, it is also critical to be able to perform well in these classes. The problem with running standard active learning algorithms in such a case is that they may not sample too many data points from these rare classes, and as a result, the model continues to perform poorly on these classes. In such cases, we can create a (small) held-out set $\mathcal { R }$ which contains data points from these rare classes, and try to encourage the AL by sampling more of these rare classes by maximizing the SMI function $I _ { f } ( \mathcal { A } ; \mathcal { R } )$ :
+
+$$
+\operatorname* { m a x } _ { \substack { A \subseteq \mathcal { U } , | \mathcal { A } | \leq B } } I _ { f } ( \mathcal { A } ; \mathcal { R } )
+$$
+
+This setting is shown in Fig. 2(a). $\mathcal { R }$ contains a small number of held-out examples of classes $5 , 8$ which are rare, and the AL acquisition function is Equ. (2). Note that this is exactly equivalent to maximizing the SCMI function with $\mathcal { Q }  \mathcal { R }$ and $\mathcal { P }  \emptyset$ (i.e. Equ. (1) in Line 5 of Algorithm 1). Furthermore, since the SMI functions naturally model query relevance and diversity, they will also try to pick a diverse set of data points which are relevant to $\mathcal { R }$ . Finally, we also point out that this setting was considered in [15] where they use a FISHER kernel based approach to sample data points. Note that for this setting to be realistic, it is critical that the size of this validation set is very small – [15] uses a much larger validation set which is not very realistic (e.g., $2 0 0 \times$ our set, see Appendix B for more details).
+
+# 3.3 Redundancy in Unlabeled Data
+
+Another commonplace scenario is where we are dealing with a lot of redundancy – e.g., frames sampled from a video, where subsequent frames are visually similar. In such cases, existing AL algorithms tend to pick data points that are semantically similar to the ones selected in some earlier batch. This is true even for the state-ofthe-art AL algorithm BADGE [3] that attempts to enforce diversity, but only in the current batch of data points and not the already selected labeled set. To illustrate this, consider the scenario in Fig. 2(b). The digits $0 , 1$ are redundant in the unlabeled set, and they are already present in the labeled set $\mathcal { L }$ . Algorithms which just focus on diversity in the current batch could fail at ensuring diversity across batches. To mitigate inter-batch redundancy, we use SCG acquisition function and condition upon the already labeled set $\mathcal { L }$ :
+
+![](images/4219dda3c670126460a44a616dc221db62caa0d80b9d16f53c6da493fd34be60.jpg)  
+Figure 2: An illustration of realistic scenarios where SIMILAR is applied with appropriate choices of query and conditioning sets: a) SIMILAR finds rare digits $5 , 8 \in { \mathcal { U } }$ , by optimizing the SMI function $I _ { f } ( A ; \mathcal { R } )$ with $\mathcal { R }$ containing 5, 8 as queries, b) select samples from $\mathcal { U }$ which are diverse among themselves and also diverse w.r.t those in $\mathcal { L }$ by optimizing $f ( A | { \mathcal { L } } )$ (here, we want to avoid digits $0 , 1 \in \mathcal { U }$ altogether because they are present in $\mathcal { L }$ ), c) select digits (in-distribution) and avoid alphabets (out-of-distribution) in $\mathcal { U }$ by optimizing $\bar { I _ { f } } ( \mathcal { A } ; \mathcal { T } | \mathcal { O } )$ , where $\mathcal { T }$ are ID labeled points and $\mathcal { O }$ are OOD points selected so far.
+
+$$
+\operatorname* { m a x } _ { \boldsymbol { A } \subseteq \mathcal { U } , | \mathcal { A } | \leq B } f ( \boldsymbol { A } | \mathcal { L } )
+$$
+
+Notice that this is a special case of our proposed unified AL framework (Equ. (1)) since the SCG function $f ( A | { \mathcal { L } } )$ is basically a SCMI function with $\mathcal { Q }  \emptyset$ and $\mathcal { P }  \mathcal { L }$ .
+
+# 3.4 Out of Distribution Data
+
+distribution (OOD) data or irrelevant classes in the unlabeled set. Such OOD data is not useful for the given classification task at hand. Using an acquisition function that selects a lot of OOD data points will lead to a waste of labeling effort and time. This is because annotators have to spend time in filtering out OOD data points and discard them from the training dataset. To account for OOD data, we add an additional class called "OOD" in our model. Since the goal is to improve on in-distribution classes , we ignore the prediction for the OOD class at test time. For our AL acquisition function, we use the currently labeled OOD points $\mathcal { O }$ as the conditioning set $\mathcal { P }$ , and the currently labeled in-distribution (ID) points $\mathcal { T }$ as the query set $\mathcal { Q }$ . In other words, our acquisition function is to optimize:
+
+$$
+\operatorname* { m a x } _ { \substack { \ r { A } \subseteq \mathcal { U } , | \mathcal { A } | \leq B } } I _ { f } ( \mathcal { A } ; \mathcal { T } | \mathcal { O } )
+$$
+
+This is illustrated in Fig. 2(c), where the labeled set consists of six examples, four of them being ID data points (set $\mathcal { T }$ ) and two being OOD data points (set $\mathcal { O }$ ). In Fig. 2(c), the ID data are digits (digit classification) and the OOD examples are alphabets. This SCMI based approach will naturally pick points "close" to the ID data while avoiding the OOD points.
+
+Another approach for designing the acquisition function is to not explicitly condition on the OOD data points. In other words, we can just optimize the SMI function:
+
+$$
+\operatorname* { m a x } _ { \ A \subseteq \mathcal { U } , | \mathcal { A } | \leq B } I _ { f } ( \mathcal { A } ; \mathcal { T } )
+$$
+
+We contrast the choices of SCMI (Equ. (4)) and SMI (Equ. (5)) functions in our experiments.
+
+# 3.5 Multiple Co-occurring Realistic Scenarios
+
+We can also apply SIMILAR to datasets where more than one realistic scenarios are co-occurring. As illustrated in Tab. 3, we can use the formulation of SCMI and make appropriate choices of $\mathcal { Q }$ and $\mathcal { P }$ to tackle multiple realistic scenarios.
+
+<table><tr><td>Function</td><td>Setting</td><td>Realistic Scenario</td></tr><tr><td>If(A;R|O)</td><td>Q←R,P←O Q←R,P←L-R</td><td>Rareclasses+OOD</td></tr><tr><td>If(A;RIC-R) If(A;I|OUI&#x27;)</td><td>Q←I,P←OUI&#x27;</td><td>Rare classes +Redundancy Redundancy + OOD</td></tr></table>
+
+Table 3: Choices for $\mathcal { Q }$ and $\mathcal { P }$ for multiple co-occuring realistic scenarios
+
+Rare classes and OOD: We set $\mathcal { Q }  \mathcal { R }$ and $\mathcal { P }  \mathcal { O }$ and maximize $I _ { f } ( { \cal { A } } ; { \mathcal { R } } | { \cal { O } } )$ . Intuitively, this function would pick points close to $\mathcal { R }$ while avoiding the OOD points. In this scenario, we can also optimize an SMI function $I _ { f } ( A ; R )$ if the data points belonging to the rare classes are not similar to the OOD data points, meaning that only searching for rare classes may suffice. Regardless, the SCMI approach above will further reinforce the avoidance of the OOD points.
+
+Rare classes and Redundancy: We set $\mathcal { Q }  \mathcal { R }$ and $\mathcal { P }  \mathcal { L } - \tilde { \mathcal { R } }$ . Here, $\tilde { \mathcal { R } }$ is the subset of data points from the labeled set $\mathcal { L }$ that belong to the rare classes. Intuitively, this function would pick points close to $\mathcal { R }$ while avoiding points already in $\mathcal { L } - \tilde { \mathcal { R } }$ , thereby avoiding redundant data. Just focusing on $\mathcal { R }$ by optimizing $I _ { f } ( A ; \mathcal { R } )$ is also a feasible option because rare classes are generally not redundant. As before, the SCMI approach will only reinforce the avoidance of redundant samples in any non-rare class instances selected.
+
+Redundancy and OOD: This is a more challenging scenario than the ones above. We start with using the SCMI formulation for the OOD scenario, i.e., $I _ { f } ( \mathcal { A } ; \mathcal { T } | \mathcal { O } )$ , where $\mathcal { T }$ is the set of ID samples and $\mathcal { O }$ is the set of OOD samples. Optimizing this function will pick diverse in-distribution samples within a batch. For selecting diverse samples across different batches, we can tackle this by using an appropriate kernel for the conditioning set. For instance, consider the FLCMI function in Tab. 2(b). On setting $\mathcal { P }  \mathcal { O } \cup \mathcal { I }$ , we can rewrite the FLCMI function by splitting the penalty term as follows: $\sum _ { i \in \mathcal { U } } \operatorname* { m a x } \bigl ( \operatorname* { m i n } ( \operatorname* { m a x } _ { j \in \mathcal { A } } S _ { i j } , \operatorname* { m a x } _ { j \in \mathcal { T } } S _ { i j } ) - \operatorname* { m a x } ( \operatorname* { m a x } _ { j \in \mathcal { O } } S _ { i j } , \operatorname* { m a x } _ { j \in \mathcal { T } } S _ { i j } ^ { \prime } ) , 0 \bigr )$ . While $S$ is computed using cosine similarity, we can compute $S ^ { \prime }$ using an exponential kernel to magnify the value of $S _ { i j } ^ { \prime }$ using the exponent when $i$ and $j$ are very similar. This exponent is a hyperparameter which can be tuned to penalize selecting redundant samples from $I$ (denoted as $I ^ { ' }$ ) in Tab. 3.
+
+# 3.6 Realizing Realistic Scenarios in Applications
+
+In this section, we discuss a few insights on how these realistic scenarios can be realized. To begin with, the initial labeled set used in AL usually follows the distribution of the unlabeled set. The statistics of this set can be used to identify rare classes. If the initial seed set is small, the rare classes/OOD data points can be realized after a few rounds of standard AL. Until such scenarios are discovered, standard AL can be done using a diversity-based acquisition function like the log determinant (LOGDET). For production-level models, they go through a test deployment phase. During this phase, systematically recurring errors are often found. An example is of undetected bicycles at night in an object detector (false negatives). Such recurring failure cases can be due to rare classes in the labeled set. Moreover, we as users often know whether there are rare classes or if there is redundancy from domain knowledge. For instance, in the biomedical domain, images of cancer cells are typically rarer than ones of non-cancer cells because cancer inherently is a rare disease.
+
+# 3.7 Scalability and Computational Aspects of SIMILAR
+
+Computational Complexity: The computational complexity of the different SMI functions are determined by (1) the kernel computation time, and (2) the time complexity of the greedy algorithm. All functions considered here are graph based functions and require computing a kernel matrix. The LOGDET functions (LOGDET, LOGDETMI, LOGDETCG, LOGDETCMI), some FL functions $( \mathrm { F L }$ , FLVMI, FLCMI), and GC, GCMI all require the $n \times n$ similarity matrix $( n = | U |$ is the number of unlabeled points) which entails a complexity of $O ( n ^ { 2 } )$ to construct the similarity kernel. Once constructed, the complexity of the greedy algorithm for LOGDET class of functions is roughly $O ( B ^ { 3 } n )$ [11], while the complexity of the greedy algorithm with FL, FLVMI, and FLCMI is $O ( B n ^ { 2 } )$ [18, 20]( $B$ is the batch size). Different from others, FLQMI does not require computing a $n \times n$ kernel, but only a $n \times q$ kernel (where $q = | \mathcal { Q } |$ is the number of query points). Correspondingly, the complexity of the greedy algorithm with FLQMI is $O ( n q B )$ , and is linear in $n$ . In Appendix. A, we provide a detailed summary of the complexity of different SF, SMI, SCG, and SCMI functions.
+
+Partition Trick: The deal with the high $O ( n ^ { 2 } )$ of the LOGDET, GC, and some of the $\mathrm { F L }$ variants (except FLQMI), we also propose the following partitioning algorithm: We randomly split the unlabeled set $\mathcal { U }$ into $p$ partitions $\mathcal { U } _ { 1 } , \cdots , \mathcal { U } _ { p }$ , and we then define the corresponding function (SF, SMI, SCMI, SCG) on each of the partitions and independently optimize them. In each partition, we select $B / p$ points. The complexity of this reduces from $O ( n ^ { 2 } )$ to $O ( n ^ { 2 } / p )$ and with an appropriate choice of $p$ , we can significantly reduce the computational complexity. We use this in our ImageNet experiments (see Sec. 4.1), and observe that our approaches continue performing well while being more scalable. We provide more details on partitioning in Appendix. A.
+
+Last Layer Gradients: Deep models have numerous parameters leading to very high dimensional gradients. Since our kernel matrix is computed using the cosine similarity of gradients, this becomes intractable for most models. To solve this problem, we use last-layer gradient approximation by representing data points using last layer gradients. BADGE [3], CORESET [40] and GLISTER [24] are other baselines that also use this approximation. Using this representation, we compute a pairwise cosine similarity matrix to instantiate acquisition functions in SIMILAR (see lines 3,4 in Algorithm 1).
+
+# 4 Experimental Results
+
+In this section, we empirically evaluate the effectiveness of SIMILAR on a wide range of scenarios like rare classes (Sec. 4.1), redundancy (Sec. 4.2) and out-of-distribution (Sec. 4.3). We do so by comparing the accuracy and selections of various SCMI based acquisition functions with existing AL approaches. Using these experiments, we cover the issues with the current AL methods and show that these issues can be mitigated by using a unified implementation using SCMI with appropriate choices of query and/or conditioning sets. Although this section focuses on realistic scenarios, we also study SIMILAR in a standard active learning setting and show that it performs at par with current AL methods (see Appendix. C). Furthermore, we present some experiments on a real-world medical dataset in Appendix. H and some experiments on multiple co-occurring realistic scenarios (Sec. 3.5) in Appendix. I.
+
+Baselines in all scenarios: We compare SCMI based functions against several methods. Particularly, we compare against: (1) three uncertainty based AL algorithms: i)ENTROPY: Selects the top $B$ data points with the highest entropy [41], ii) MARGIN: Select the bottom $B$ data points that have the least difference in the confidence of first and the second most probable labels [37], iii)LEAST-CONF: Select $B$ samples with the smallest predicted class probability [44], (2) state-of-the-art diversity based algorithms: iv) BADGE [3] v) GLISTER [24] vi) CORESET [40] which are all discussed in section Sec. 1.1, and, 3) RANDOM: Select $B$ samples randomly. Additionally, in the rare classes scenario, we compare against FISHER [15] which is also discussed in Sec. 1.1.
+
+![](images/d96c65243fe1355410783da25412c46f86413f350a364b60810116b247f9ef55.jpg)  
+Figure 3: Active Learning with rare classes on CIFAR-10 (top row), MNIST (middle row), and ImageNet (bottom row). Left side plots (a,d,g) are rare class accuracies, center plots (b,e,h) are overall test accuracies, right plots (c,f,i) are a number of rare class samples selected. The SMI functions (specifically LOGDETMI, FLQMI) outperform other baselines by more than $10 \%$ on the rare classes.
+
+Datasets, model architecture and experimental setup: We apply our framework to CIFAR-10 [27] and MNIST [30] classification tasks. Additionally, we also evaluate our method on down sampled $3 2 \times$ 32 ImageNet-2012 [38] for the rare classes setting (Sec. 4.1). Due to the lack of test split on ImageNet, we used the validation split for evaluation. In the sections below, we discuss the individual splits for $\mathcal { L } , \mathcal { U } , \mathcal { R } , \mathcal { Z }$ , and $\mathcal { O }$ in each realistic scenario. To ensure that all the selection algorithms that we are studying are given fair and equal treatment across all realistic scenarios, we use a common training procedure and hyperparameters. We use standard augmentation techniques like random crop, horizontal flip followed by data normalization except for MNIST which does not use horizontal flip to preserve labels. For training, we use an SGD optimizer with an initial learning rate of 0.01, the momentum of 0.9, and a weight decay of 5e-4. We decay the learning rate using cosine annealing [31] for each epoch. On all datasets except MNIST, we train a ResNet18 [17] model, while on MNIST we train a LeNet [29] model. For all the experiments in a particular scenario (rare classes, redundancy and OOD), we start with an identical initial model $\mathcal { M }$ and initial labeled set $\mathcal { D }$ . We reinitialize the model parameters at the beginning of every selection round using Xavier initialization and train the model until either the training accuracy reaches $9 9 \%$ or the epoch count reaches 150. We run each experiment $3 \times$ on CIFAR10 and MNIST and $1 \times$ on ImageNet and provide error bars (std deviation). All experiments were run on a V100 GPU. For more details on the experimental setup, baselines, and datasets see Appendix. B.
+
+# 4.1 Rare Classes
+
+Custom dataset: Following [15, 24], we simulate these rare classes by creating a class imbalance. We initialize the batch active learning experiments by creating a custom dataset which is a subset of the full dataset with the same marginal distribution. Given that $\mathcal { C }$ consists of data points from the imbalanced classes and $\mathcal { D }$ consists of data points from the balanced classes, we create an initial labeled set $\mathcal { L }$ such that $| \mathcal { D } _ { \mathcal { L } } | = \rho | \mathcal { C } _ { \mathcal { L } } |$ and an unlabeled set $| \mathcal { D } \boldsymbol { u } | = \rho | \mathcal { C } _ { \mathcal { U } } |$ , where $\rho$ is the imbalance factor. We use a small and clean validation/query set $\mathcal { R }$ containing data points from the imbalanced classes $\approx 3$ data points per imbalanced class). We create an imbalance in CIFAR-10 using 5 random classes, $\rho = 1 0$ and for MNIST we create an imbalance using the same classes as in [15] $( 5 \cdots 9 )$ and use $\rho = 2 0$ . For both datasets: $| \mathcal { C } _ { \mathcal { L } } | + | \mathcal { D } _ { \mathcal { L } } | = 1 2 5$ , $| \mathcal { C } _ { \mathcal { U } } | + | \mathcal { D } \mathcal { U } | = 1 6 . 5 K$ , $B = 1 2 5$ (AL batch size) and, $| \mathcal { R } | = 2 5$ (size of the held out rare instances). For MNIST, we also present the results for $B = 2 5$ and $\rho = 1 0 0$ in the supplementary. On ImageNet, we randomly select 500 classes out of 1000 classes for imbalance and $\rho = 5$ such that $| \mathcal { C } _ { \mathcal { L } } | + | \mathcal { D } _ { \mathcal { L } } | = 1 0 2 K$ , $| { \mathcal C } _ { \mathcal U } | + | { \mathcal D } _ { { \mathcal U } } | = 6 6 4 K .$ $B = 2 5 K$ and, $| \mathcal { R } | = 2 . 5 K$ . These data splits are chosen to simulate a low initial accuracy on the rare classes and at the same time maintain the imbalance factor in the labeled and unlabeled datasets.
+
+![](images/05a9ef193925c2947e566d0dc0b420b7c19832834de37b0b8fc581d2fabdda87.jpg)  
+Figure 4: Active Learning under $1 0 \times$ redundancy for CIFAR-10 and MNIST. The CG functions (LOGDETCG, FLCG) pick more unique points and outperform existing algorithms including BADGE.
+
+Results: The results are shown in Fig. 3. We observe that SMI based functions not only consistently outperform uncertainty based methods (ENTROPY, LEAST-CONF and MARGIN) but also all the state-of-the-art diversity based methods (BADGE, GLISTER, CORESET) by $\approx 5 - 1 0 \%$ in terms of overall accuracy and $\approx 1 0 - 1 8 \%$ in terms of average accuracy on rare classes (see Fig. 3a, 3d, $3 \mathrm { g }$ ). The reason for the same can be seen in Fig. 3c, 3f, 3i which illustrates that they fail to pick an adequate number of examples from the rare classes. Evidently, FLQMI and LOGDETMI which balance between diversity and relevance perform better than GCMI which only models relevance. Furthermore, DIV-GCMI which is a linear combination of GCMI and a diversity term performs consistently worse, which suggest that a naive combination of the two may not be as effective. This suggests the need of SMI based acquisitions functions (Equ. (2)) with richer modeling capabilities like FLQMI and LOGDETMI within SIMILAR. Furthermore, all SMI based functions also outperform the FISHER kernel based method when the validation set is small and realistic, i.e., $| \mathcal { R } | = 2 5$ . Since, [15] use a very large validation set in their experiments, we try their method FISHER-LV with a $4 0 \times$ larger validation set of size 1000 (which is not practical) and observe a comparable performance with the SMI functions which use a small validation set. Furthermore, we see that FISHER-LV actually picks significantly larger number of rare class instances in MNIST, but yet is comparable in performance of FLQMI and LOGDETMI. This suggests that both these methods select higher quality and diverse rare class instances. We observe that the GC SMI variants( GCMI and DIV-GCMI) do not perform well on MNIST classification. Finally, we point out in the case of ImageNet, FLQMI performs the best and outperforms FLVMI and LOGDETMI – this is because we do not need to do the partition trick for FLQMI since it is already linear in time complexity. For FLVMI and LOGDETMI, we set the number of partitions $p = 5 0$ for ImageNet. Finally, we do a pairwise $t { \cdot }$ -test to compare the performance of the algorithms (Appendix. D) and observe that the SMI functions (and particularly FLVMI and LOGDETMI) statistically significantly outperform all AL baselines.
+
+# 4.2 Redundancy
+
+Custom dataset: To simulate a realistic redundancy scenario we create a custom dataset by duplicating $2 0 \%$ of the unlabeled dataset $1 0 \times$ . For CIFAR-10, the number of unique points in the unlabeled set $| \mathcal { U } | = 5 K$ , the initial labeled set $| \mathcal { L } | = 5 0 0$ , $B = 5 0 0$ , whereas for MNIST $| \mathcal { U } | = 5 0 0$ , $| \mathcal { L } | = 5 0$ and $B = 5 0$ . For MNIST, we also present the results for $5 \times$ and $2 0 \times$ in the Appendix. E.
+
+SCG vs Baselines: As expected, the diversity and uncertainty based methods outperform random. Importantly, we observe that the SCG functions (FLCG and LOGDETCG) significantly outperform all baselines by $\approx 3 - 5 \%$ towards the end as the conditioning gets stronger with increase in $\mathcal { L }$ (see Fig. 4a, 4b). This implies that simply relying on model parameters for diversity and/or uncertainty is not sufficient and that conditioning on the updated labeled set $\mathcal { L }$ (Equ. (3)) is required in batch active learning. In Fig. 4c we show that SCG based acquisition functions select significantly more unique data points than other baselines. We also perform a pairwise t-test (Appendix. E), to prove that the SCG functions consistently and statistically significantly outperform BADGE and other baselines.
+
+# 4.3 Out-Of-Distribution
+
+Custom dataset: We simulated a scenario where we convert the classification problem in CIFAR-10 and MNIST to a 8-class classification, where the first 8 classes represent the set $\mathcal { T } _ { F }$ of in-distribution (ID) data points and the last 2 represent the set ${ \mathcal { O } } _ { F }$ of out-of-distribution(OOD) data points. The initial labeled set $\mathcal { L }$ consists only of $\mathit { I D }$ points, i.e. $\mathcal { O } _ { F } \cap \mathcal { L } = \emptyset$ . The unlabeled set is simulated to reflect a realistic and somewhat extreme setting where the unlabeled ID data points $| \mathcal { T } _ { F } |$ is much smaller than the unlabeled OOD data points $| \mathcal { O } _ { F } |$ . Additionally, we also assume we have a very small validation set of ID points $\mathcal { T } _ { V }$ . For CIFAR-10: $| \mathcal { L } | = 1 . 6 K$ , $\vert \mathcal { I } _ { F } \vert = 4 K$ , $| \mathcal { O } _ { F } | = 1 0 K$ , $\vert \mathcal { T } _ { V } \vert = 4 0$ , $B = 2 5 0$ whereas for MNIST which is a relatively simpler task, we use a smaller initial labeled sets and keep the unlabeled sets of the same size: $| { \mathcal { L } } | = 4 0$ , $| \mathcal { T } _ { F } | = 4 0 0$ , $| \mathcal { O } _ { F } | = 1 0 K$ , $\vert \mathcal { I } _ { V } \vert = 1 6$ , $B = 2 0$ . Recall that our algorithm uses ID set $\mathcal { T }$ (initialized to $\mathcal { T } _ { V }$ ) and OOD set $\mathcal { O }$ which we build as follows. Every time our selection approach selects a set $\mathcal { A }$ , we update $\mathcal { T } = \mathcal { T } \cup ( \mathcal { A } \cap \mathcal { Z } _ { F } )$ and $\mathcal { O } = \mathcal { O } \cup ( \mathcal { A } \cap \dot { \mathcal { O } } _ { F } )$ , i.e. we augment the ID and OOD points in $\mathcal { A }$ to the sets $\mathcal { T }$ and $\mathcal { O }$ respectively.
+
+![](images/a4bffb5fa27c18c0f868a213e025142d64bff0fdad1ad9dd3783d48852fbccbf.jpg)  
+Figure 5: Active Learning with OOD data in unlabeled set. Top row: CIFAR-10 results for (a) SCMI vs Baselines, (b) SCMI vs SMI, and (c) variance comparison of different baselines, bottom row: MNIST results for (d) SCMI vs Baselines, (e) SCMI vs SMI, and (f) Number of ID points selected. We see that, i) the SCMI functions consistently outperform the baselines by $5 \% - \ \mathrm { \bar { 1 0 \% } }$ , ii) SCMI functions outperform the corresponding SMI functions for later rounds, and (iii) SCMI functions have the least variance compared to the rest, showing that they are more robust in performance.
+
+SCMI vs Baselines: Since we care about the predictive performance of the ID classes, we report the ID classes accuracy. We see that SCMI based acquisition functions significantly outperform existing AL approaches by $\approx 5 - 1 0 \%$ (see Fig. 5a, 5d). We also observe that existing acquisition functions have a high variance, which is undesirable in real-world deployment scenarios where deep models are being continuously developed. Our SCMI based acquisition functions (LOGDETCMI and FLCMI) show the lowest variance in training (see Fig. 5c). This reinforces the need of having a framework like SIMILAR that facilitates query and conditioning sets.
+
+SCMI vs SMI: We compare SCMI functions against SMI functions to study the effect of conditioning and observe that the SCMI functions are comparable to the SMI functions initially but in the later selection rounds of active learning, the SCMI functions consistently outperform SMI functions. In particular, we see an improvement of $2 - 3 \%$ as the conditioning becomes stronger (see Fig. 5b, 5e). We also observe the SCMI tends to select more ID points than SMI and other baselines (see Fig. 5f), and SCMI functions have a lower variance overall compared to even the SMI functions (Fig. 5c).
+
+# 5 Conclusion
+
+In this paper, we proposed a unified active learning framework SIMILAR using the submodular information functions. We showed the applicability of the framework in three realistic scenarios for active learning, namely rare classes, redundancy, and out of distribution data. In each case, we observed that the functions in SIMILAR significantly outperform existing baselines in each of these tasks. Our real-world experiments on MNIST, CIFAR-10, and ImageNet show that many of the SIM functions (specifically the LOGDET and FL variants) yield $\approx \mathrm { \tilde { 5 } \% } - 1 8 \%$ gain compared to existing baselines, particularly in the rare class scenario and $\ddot { \approx } 5 \% - 1 0 \%$ OOD scenarios. The main limitations of our work is the dependence on good representations to compute similarity. A potential negative societal impact of this work is the use of SIMILAR to perpetuate certain biases through a malicious use of the query and conditioning set. We discuss this in more detail in Appendix. G.
+
+# Acknowledgments and Disclosure of Funding
+
+This work is supported by the National Science Foundation under Grant No. IIS-2106937, a startup grant from UT Dallas, and by a Google and Adobe research award. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the National Science Foundation, Google or Adobe.
+
+# References
+
+[1] Sami Abu-El-Haija, Nisarg Kothari, Joonseok Lee, Paul Natsev, George Toderici, Balakrishnan Varadarajan, and Sudheendra Vijayanarasimhan. Youtube-8m: A large-scale video classification benchmark. arXiv preprint arXiv:1609.08675, 2016.   
+[2] David Arthur and Sergei Vassilvitskii. k-means $^ { + + }$ : the advantages of careful seeding. In SODA ’07: Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, pages 1027–1035, Philadelphia, PA, USA, 2007. Society for Industrial and Applied Mathematics. ISBN 978-0-898716-24-5.   
+[3] Jordan T Ash, Chicheng Zhang, Akshay Krishnamurthy, John Langford, and Alekh Agarwal. Deep batch active learning by diverse, uncertain gradient lower bounds. arXiv preprint arXiv:1906.03671, 2019.   
+[4] Francis Bach. Learning with submodular functions: A convex optimization perspective. arXiv preprint arXiv:1111.6453, 2011.   
+[5] Francis Bach. Submodular functions: from discrete to continuous domains. Mathematical Programming, 175(1):419–459, 2019.   
+[6] Christopher Berlind and Ruth Urner. Active nearest neighbors in changing environments. In International Conference on Machine Learning, pages 1870–1879. PMLR, 2015.   
+[7] Joy Buolamwini and Timnit Gebru. Gender shades: Intersectional accuracy disparities in commercial gender classification. In Conference on fairness, accountability and transparency, pages 77–91. PMLR, 2018.   
+[8] Holger Caesar, Varun Bankiti, Alex H Lang, Sourabh Vora, Venice Erin Liong, Qiang Xu, Anush Krishnan, Yu Pan, Giancarlo Baldan, and Oscar Beijbom. nuscenes: A multimodal dataset for autonomous driving. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 11621–11631, 2020.   
+[9] Colin Campbell, Nello Cristianini, Alex Smola, et al. Query learning with large margin classifiers. In ICML, volume 20, page 0, 2000.   
+[10] Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling. arXiv preprint arXiv:1312.3005, 2013.   
+[11] Laming Chen, Guoxin Zhang, and Hanning Zhou. Fast greedy map inference for determinantal point process to improve recommendation diversity. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pages 5627–5638, 2018.   
+[12] Shai Fine, Ran Gilad-Bachrach, and Eli Shamir. Query by committee, linear separation and random walks. Theoretical Computer Science, 284(1):25–51, 2002.   
+[13] Yoav Freund, H Sebastian Seung, Eli Shamir, and Naftali Tishby. Selective sampling using the query by committee algorithm. Machine learning, 28(2):133–168, 1997.   
+[14] Satoru Fujishige. Submodular functions and optimization. Elsevier, 2005.   
+[15] Denis Gudovskiy, Alec Hodgkinson, Takuya Yamaguchi, and Sotaro Tsukizawa. Deep active learning for biased datasets via fisher kernel self-supervision. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9041–9049, 2020.   
+[16] Anupam Gupta and Roie Levin. The online submodular cover problem. In ACM-SIAM Symposium on Discrete Algorithms, 2020.   
+[17] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.   
+[18] Rishabh Iyer and Jeffrey Bilmes. A memoization framework for scaling submodular optimization to large scale problems. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 2340–2349. PMLR, 2019.   
+[19] Rishabh Iyer, Ninad Khargoankar, Jeff Bilmes, and Himanshu Asanani. Submodular combinatorial information measures with applications in machine learning. In Algorithmic Learning Theory, pages 722–754. PMLR, 2021.   
+[20] Rishabh Krishnan Iyer. Submodular optimization and machine learning: Theoretical results, unifying and scalable algorithms, and applications. PhD thesis, 2015.   
+[21] Kimmo Karkkainen and Jungseock Joo. Fairface: Face attribute dataset for balanced race, gender, and age for bias measurement and mitigation. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 1548–1558, 2021.   
+[22] Vishal Kaushal, Rishabh Iyer, Suraj Kothawade, Rohan Mahadev, Khoshrav Doctor, and Ganesh Ramakrishnan. Learning from less data: A unified data subset selection and active learning framework for computer vision. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 1289–1299. IEEE, 2019.   
+[23] Vishal Kaushal, Suraj Kothawade, Ganesh Ramakrishnan, Jeff Bilmes, and Rishabh Iyer. Prism: A unified framework of parameterized submodular information measures for targeted data subset selection and summarization. arXiv preprint arXiv:2103.00128, 2021.   
+[24] Krishnateja Killamsetty, Durga Sivasubramanian, Ganesh Ramakrishnan, and Rishabh Iyer. Glister: Generalization based data subset selection for efficient and robust learning. arXiv preprint arXiv:2012.10630, 2020.   
+[25] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   
+[26] Andreas Kirsch, Joost Van Amersfoort, and Yarin Gal. Batchbald: Efficient and diverse batch acquisition for deep bayesian active learning. arXiv preprint arXiv:1906.08158, 2019.   
+[27] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   
+[28] Alex Kulesza and Ben Taskar. Determinantal point processes for machine learning. arXiv preprint arXiv:1207.6083, 2012.   
+[29] Yann LeCun, Bernhard Boser, John S Denker, Donnie Henderson, Richard E Howard, Wayne Hubbard, and Lawrence D Jackel. Backpropagation applied to handwritten zip code recognition. Neural computation, 1(4):541–551, 1989.   
+[30] Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. at&t labs, 2010.   
+[31] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.   
+[32] Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015.   
+[33] Baharan Mirzasoleiman, Ashwinkumar Badanidiyuru, Amin Karbasi, Jan Vondrák, and Andreas Krause. Lazier than lazy greedy. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 29, 2015.   
+[34] George L Nemhauser, Laurence A Wolsey, and Marshall L Fisher. An analysis of approximations for maximizing submodular set functions—i. Mathematical programming, 14(1):265–294, 1978.   
+[35] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.   
+[36] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, highperformance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019. URL http://papers.neurips.cc/paper/ 9015-pytorch-an-imperative-style-high-performance-deep-learning-library. pdf.   
+[37] Dan Roth and Kevin Small. Margin-based active learning for structured output spaces. In European Conference on Machine Learning, pages 413–424. Springer, 2006.   
+[38] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.   
+[39] Greg Schohn and David Cohn. Less is more: Active learning with support vector machines. In ICML, volume 2, page 6. Citeseer, 2000.   
+[40] Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set approach. arXiv preprint arXiv:1708.00489, 2017.   
+[41] Burr Settles. Active learning literature survey. 2009.   
+[42] Samarth Sinha, Sayna Ebrahimi, and Trevor Darrell. Variational adversarial active learning. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5972–5981, 2019.   
+[43] Ehsan Tohidi, Rouhollah Amiri, Mario Coutino, David Gesbert, Geert Leus, and Amin Karbasi. Submodularity in action: From machine learning to signal processing applications. IEEE Signal Processing Magazine, 37(5):120–133, 2020.   
+[44] Dan Wang and Yi Shang. A new active labeling method for deep learning. In 2014 International joint conference on neural networks (IJCNN), pages 112–119. IEEE, 2014.   
+[45] Kai Wei, Rishabh Iyer, and Jeff Bilmes. Submodularity in data subset selection and active learning. In International Conference on Machine Learning, pages 1954–1963. PMLR, 2015.   
+[46] Xiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. arXiv preprint arXiv:1509.01626, 2015.   
+[47] Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In Proceedings of the IEEE international conference on computer vision, pages 19–27, 2015.

parse/train/x_n34KpwAvI/x_n34KpwAvI_content_list.json

@@ -0,0 +1,1217 @@
+[
+    {
+        "type": "text",
+        "text": "SIMILAR: Submodular Information Measures Based Active Learning In Realistic Scenarios ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            122,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Suraj Kothawade University of Texas at Dallas suraj.kothawade@utdallas.edu ",
+        "bbox": [
+            238,
+            226,
+            480,
+            266
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nathan Beck University of Texas at Dallas nathan.beck@utdallas.edu ",
+        "bbox": [
+            552,
+            226,
+            759,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Krishnateja Killamsetty University of Texas at Dallas krishnateja.killamsetty@utdallas.edu ",
+        "bbox": [
+            212,
+            287,
+            521,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rishabh Iyer University of Texas at Dallas rishabh.iyer@utdallas.edu ",
+        "bbox": [
+            568,
+            287,
+            784,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            363,
+            535,
+            380
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Active learning has proven to be useful for minimizing labeling costs by selecting the most informative samples. However, existing active learning methods do not work well in realistic scenarios such as imbalance or rare classes, out-of-distribution data in the unlabeled set, and redundancy. In this work, we propose SIMILAR (Submodular Information Measures based actIve LeARning), a unified active learning framework using recently proposed submodular information measures (SIM) as acquisition functions. We argue that SIMILAR not only works in standard active learning but also easily extends to the realistic settings considered above and acts as a one-stop solution for active learning that is scalable to large real-world datasets. Empirically, we show that SIMILAR significantly outperforms existing active learning algorithms by as much as $\\approx 5 \\% - \\mathrm { \\bar { 1 } 8 \\% }$ in the case of rare classes and $\\approx 5 \\% - 1 \\mathrm { \\bar { 0 } \\% }$ in the case of out-of-distribution data on several image classification tasks like CIFAR-10, MNIST, and ImageNet. SIMILAR is available as a part of the DISTIL toolkit: https://github.com/decile-team/distil. ",
+        "bbox": [
+            233,
+            395,
+            766,
+            583
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            310,
+            625
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNNs) have had a lot of success in a wide variety of domains. However, they require large labeled datasets which are often taxing, time-consuming, and expensive to obtain. Active learning (AL) [12, 13, 39, 3, 9] is a promising approach to solve this problem. It aims to select the most informative data points from an unlabeled dataset to be labeled in an adaptive manner with a human in the loop. The goal of AL is to achieve maximum accuracy of the model while minimizing the number of data points required to be labeled. ",
+        "bbox": [
+            174,
+            638,
+            483,
+            799
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Current AL methods have been tested in relatively simple, clean, and balanced datasets. However, real-world datasets are not clean and have a number of characteristics that makes learning from them challenging [10, 46, 47, 38, 1, 8]. Firstly, these real-world datasets are im",
+        "bbox": [
+            174,
+            806,
+            485,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/a48dfbee6ce2308ced0121a6e7825fa32b4f4a129cb71e47debd6343efc58b1c.jpg",
+        "image_caption": [
+            "Figure 1: Motivating scenarios for realistic active learning: (a) rare classes: digits 5 and 8 are rare; (b) redundancy: digits 0 and 1 are redundant; (c) out-of-distribution (OOD): letters A, R, B, F in digit classification. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            657,
+            821,
+            787
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "balanced, and some classes are very rare (e.g., Fig 1(a)). Examples of this imbalance are medical imaging domains where the cancerous images are rare. Secondly, real-world data has a lot of redundancy (e.g., Fig 1(b)). This redundancy is more prominent in datasets that are created by sampling frames from videos (e.g., footage from a car driving on a freeway or surveillance camera footage). Thirdly, it is common to have out-of-distribution (OOD) (e.g., Fig 1(c)) data, where some part of the unlabeled data is not of concern to the task at hand. Given the amount of unlabeled data, it is not realistic to assume that these datasets can be cleaned manually; hence, it is the need of the hour to have active learning methods that are robust to such scenarios. We show that current AL approaches (including the state-of-the-art approach BADGE [3]) do not work well in the presence of the dataset biases described above. In this work, we address the following question: Can a machine learning model be trained using a single unified active learning framework that works for a broad spectrum of realistic scenarios? As a solution, we propose SIMILAR1, a unified active learning framework which enables active learning for many realistic scenarios like rare classes, out-of-distribution (OOD) data, and redundancy. ",
+        "bbox": [
+            174,
+            886,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            265
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            282,
+            308,
+            296
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Active learning has enabled efficient training of complex deep neural networks by decreasing labeling costs. The most commonly used approach is to select the most uncertain items. Examples of uncertainty strategies include ENTROPY [41], LEAST CONFIDENCE [44], and MARGIN [37]. One challenge of this approach is that all the samples within a batch can be potentially similar even though they are uncertain. To overcome this problem in batch active learning, many recent works have attempted to select diverse yet informative data points. [45, 22] propose a simple approach: Filter a set of points using uncertainty sampling and then select a diverse subset from the filtered set. [40] propose CORESET, which forms core-sets using greedy $k$ -center clustering while maintaining the geometric arrangement. BADGE [3], another recent approach, proposes to select data points corresponding to high-magnitude, diverse hypothesized gradients by using ${ \\mathrm { K } } { \\mathrm { - } } { \\mathrm { M E A N S } } { + + }$ [2] initialization to distance from previously selected data points in the batch. Most existing AL approaches fail to ensure diversity across AL selection rounds and do not perform as well when there is a lot of redundancy. Sinha et al. [42] used a variational autoencoder (VAE) [25] to learn a feature space and an adversarial network [32] to distinguish between labeled and unlabeled data points. However, their approach is computationally expensive and requires extensive hyperparameter tuning. Similarly, BATCHBALD [26] does not scale to larger batch sizes since their method would need a large number of Monte Carlo dropout samples to obtain a significant mutual information. Such limitations reduce the scope of applying these methods to realistic settings. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Closely related to our work are two recently proposed works. The first is GLISTER-ACTIVE [24], which formulates the AL acquisition function by maximizing the log-likelihood on a held-out validation set. This validation set could consist of examples from the rare classes or in-distribution examples. The second approach is the work of Gudovskiy et al. [15], who study AL for biased datasets using a self-supervised FISHER kernel and pseudo-label estimators. They address this problem by explicitly minimizing the KL divergence between training and validation sets via maximizing the FISHER kernel. Although their method shows promising results, they make multiple unrealistic assumptions: a) They use a large labeled validation set, and b) they use feature representations from a model pretrained using unsupervised learning on a balanced unlabeled dataset. In this work, we compare against both GLISTER-ACTIVE [24] and FISHER [15] approaches in the more realistic setting of a small held-out validation set (smaller than the seed labeled set) and an imbalanced unlabeled set. Another work proposed a discrete optimization method for $k$ -NN-type algorithms in the domain shift setting [6]. However, their approach is limited to $k$ -NNs. ",
+        "bbox": [
+            174,
+            555,
+            825,
+            729
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This work utilizes submodular information measures (SIM) by [19] and their extensions by [23]. SIMs encompass submodular conditional mutual information (SCMI), which can then be used to derive submodular mutual information (SMI); submodular conditional gain (SCG); and submodular functions (SF). We discuss these functions in detail in Sec. 2. [23] also studies these functions on the closely related problem of targeted data selection. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            803
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.2 Our Contributions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            819,
+            343,
+            834
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The following are our main contributions: 1) Given the limitations of existing approaches in handling active learning in the real world, we propose SIMILAR (Sec. 3), a unified active learning framework that can serve as a comprehensive solution to multiple realistic scenarios. 2) We treat SIM as a common umbrella for realistic active learning and study the effect of different function instantiations offered under SIM for various realistic scenarios. 3) SIMILAR not only handles standard active learning but also extends to a wide range of settings which appear in the real world such as rare classes, out-of-distribution (OOD) data, and datasets with a lot of redundancy. Finally, 4) we empirically demonstrate the effectiveness of SMI-based measures for image classification (Sec. 4) in a number of realistic data settings including imbalanced, out-of-distribution, and redundant data. Specifically, in the case of imbalanced and OOD data, we show that SIMILAR achieves improvements of more than 5 to $10 \\%$ on several image classification datasets. ",
+        "bbox": [
+            176,
+            844,
+            825,
+            886
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            217,
+            308,
+            234
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we enumerate the different submodular functions that are covered under SIM and the relationships between them. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            275
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Submodular Functions. We let $\\mathcal { U }$ denote the unlabeled set of $n$ data points $\\mathcal { U } = \\{ 1 , 2 , 3 , . . . , n \\}$ and a set function $f : 2 ^ { \\mathcal { U } } \\to \\mathbb { R }$ . Formally, a function $f$ is submodular [14] if for $x \\in \\mathcal { U }$ , $f ( { \\mathcal { A } } \\cup { \\mathcal { x } } ) - f ( { \\mathcal { A } } ) \\geq$ $f ( B \\cup x ) - { \\overline { { f ( B ) } } }$ , $\\forall { \\mathcal { A } } \\subseteq B \\subseteq { \\mathcal { U } }$ and $x \\notin B$ . For a set ${ \\mathcal { A } } \\subseteq { \\mathcal { U } }$ , $f ( A )$ provides a real-valued score for $\\mathcal { A }$ . In the context of batch active learning, this is the score of an acquisition function $f$ on batch $\\mathcal { A }$ . Submodularity is particularly appealing because it naturally occurs in real world applications [43, 4, 5, 20] and also admits a constant factor $1 - { \\frac { 1 } { e } }$ [34] for cardinality constraint maximization. Additionally, variants of the greedy algorithm maximize a submodular function in near-linear time [33]. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            378
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Submodular Mutual Information (SMI). Given sets ${ \\mathcal { A } } , { \\mathcal { Q } } \\subseteq { \\mathcal { U } }$ , the SMI [16, 19] is defined as $I _ { f } ( A ; \\mathcal { Q } ) = f ( A ) + f ( \\mathcal { Q } ) - f ( A \\cup \\mathcal { Q } )$ . Intuitively, SMI models the similarity between $\\mathcal { Q }$ and $\\mathcal { A }$ and maximizing SMI will select points similar to $\\mathcal { Q }$ while being diverse. $\\mathcal { Q }$ here is the query set. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            425
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Submodular Conditional Gain (SCG). Given sets $\\mathcal { A } , \\mathcal { P } \\subseteq \\mathcal { U }$ , the SCG $f ( A | \\mathcal { P } )$ is the gain in function value by adding $\\mathcal { A }$ to $\\mathcal { P }$ . Thus, $f ( A | \\mathcal { P } ) = f ( A \\cup \\mathcal { P } ) - f ( \\mathcal { P } )$ [19]. Intuitively, SCG models how different $\\mathcal { A }$ is from $\\mathcal { P }$ , and maximizing SCG functions will select data points not similar to the points in $\\mathcal { P }$ while being diverse. We refer to $\\mathcal { P }$ as the conditioning set. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            486
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Submodular Conditional Mutual Information (SCMI). Given sets $\\mathcal { A } , \\mathcal { Q } , \\mathcal { P } \\subseteq \\mathcal { U }$ , the SCMI is defined as $I _ { f } ( { \\cal { A } } ; { \\cal { Q } } | { \\mathcal { P } } ) = f ( { \\cal { A } } \\cup { \\mathcal { P } } ) + f ( { \\cal { Q } } \\cup { \\mathcal { P } } ) - f ( { \\cal { A } } \\cup { \\cal { Q } } \\cup { \\mathcal { P } } ) - f ( { \\mathcal { P } } )$ . Intuitively, SCMI jointly models the similarity between $\\mathcal { A }$ and $\\mathcal { Q }$ and their dissimilarity with $\\mathcal { P }$ . ",
+        "bbox": [
+            173,
+            491,
+            823,
+            532
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Relationship between SIM The relationship between the above measures is the key component that unifies our AL framework [19, 23]. The unification comes from the rich modeling capacity of SCMI: $I _ { f } ( { \\cal { A } } ; \\mathcal { Q } | \\mathcal { P } )$ where $\\mathcal { Q } , \\mathcal { P } \\subseteq \\mathcal { U }$ . This facilitates a single acquisition function that can be applied to multiple scenarios. Concretely, the submodular function $f$ can be obtained ",
+        "bbox": [
+            174,
+            537,
+            460,
+            659
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/dc92c9709295048183fd141701a2198e3414224ca6b8c5c63593ac77ed868485.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Function</td><td>Setting</td><td>Realistic Scenario</td></tr><tr><td>Submodular</td><td>Q←U,P←0</td><td>Standard AL</td></tr><tr><td>SMI</td><td>Q↑ Q,P←0</td><td>Imbalance,OOD</td></tr><tr><td>SCG</td><td>Q←,P←p</td><td>Redundancy</td></tr><tr><td>SCMI</td><td>Q←Q,P←P</td><td>0OD</td></tr></table>",
+        "bbox": [
+            472,
+            555,
+            821,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Relationship between SIM and their applications to realistic scenarios by choices of $\\mathcal { Q }$ and $\\mathcal { P }$ . ",
+        "bbox": [
+            473,
+            626,
+            825,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "by setting $\\mathcal { Q }  \\mathcal { U }$ and $\\mathcal { P }  \\emptyset$ . Next, the SMI can be obtained by setting $\\mathcal { Q }  \\mathcal { Q }$ and $\\mathcal { P }  \\emptyset$ , while we obtain SCG by setting $\\mathcal { Q }  \\emptyset$ , $\\mathcal { P }  \\mathcal { P }$ . We summarize the relationships between SIM in Tab. 1. ",
+        "bbox": [
+            173,
+            659,
+            825,
+            686
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Instantiations of SIM. The formulations for Facility Location (FL), Graph Cut (GC) and Log Determinant (LOGDET) are as in [19, 23] and we adapt them as acquisition functions for batch active learning. We use two variants for FL: FLQMI, which models pairwise similarities of only the query set $\\mathcal { Q }$ to the unlabeled dataset, and FLVMI, which additionally considers the pairwise similarities within the unlabeled dataset $\\mathcal { U }$ . The SCG and SCMI expressions corresponding to $\\mathrm { F L }$ are referred as FLCG and FLCMI, respectively (see row 1 in Tab. 2a and 2b). For LOGDET, we refer to the SMI, SCG and SCMI expressions as LOGDETMI, LOGDETCG and LOGDETCMI, respectively (see row 5 in Tab. 2a and row 2 in Tab. 2b). Similarly, the SMI and SCG expressions are respectively referred to as GCMI and GCCG for GC (see row 3 in Tab. 2a and 2b). For notation in Tab. 2, the pairwise similarity matrix $S$ between items in sets $\\mathcal { A }$ and $\\boldsymbol { B }$ is denoted as $S _ { A , B }$ . Also, we denote $S _ { i j }$ as the $( i , j )$ entry of $S$ . ",
+        "bbox": [
+            173,
+            691,
+            825,
+            827
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 SIMILAR: Our Unified Active Learning Framework ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            839,
+            638,
+            857
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose a unified active learning framework SIMILAR, which uses SIMs to address the limitations of the current work (see Sec. 1.1). We show that SIMILAR can be effectively applied to a broad range of realistic scenarios and thus acts as one-stop solution for AL. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Instantiations of SIM. Note how the relationships in Tab. 1 can be applied to SCMI instantiations to obtain SMI and SCG instantiations. ",
+        "bbox": [
+            171,
+            97,
+            825,
+            125
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(a) Instantiations of SMI functions. ",
+        "bbox": [
+            200,
+            147,
+            408,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/0fa8dfc01b9411311f831f265a2df5d677e6b25e95756c7f0a5cade1ecac00b9.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SMI</td><td>If(A; Q)</td></tr><tr><td>FLVMI</td><td>E min(max Sij，max Sij） jEA jEQ</td></tr><tr><td>FLQMI</td><td>M max Sij+ ∑max Sij iEQJEA iEAJEQ</td></tr><tr><td>GCMI</td><td>2M M Sij</td></tr><tr><td>LOGDETMI</td><td>iEAjEQ log det(SA)-log det(SA- SAQS1ST.Q)</td></tr></table>",
+        "bbox": [
+            178,
+            166,
+            431,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/62ce6ae37f7f0d6ac9a761c23c91ac14899fa332c53ed4477eb0ac584efdf545.jpg",
+        "table_caption": [
+            "(b) Instantiations of SCG and SCMI functions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SCG</td><td>f(AP)</td></tr><tr><td>FLCG</td><td>M max(max Sij-max Sij,0) iEu jEA jEp</td></tr><tr><td>LogDetCG</td><td></td></tr><tr><td>GCCG</td><td>f(A)-2∑ Sij iEA,j∈P</td></tr></table>",
+        "bbox": [
+            491,
+            151,
+            759,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/1e4cd9a5ba40c218bd4a88ef8db090ef1a62465f1dd37bc707b4af12b6275f8f.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SCMI</td><td colspan=\"2\">If(A; Q|P)</td></tr><tr><td>FLCMI</td><td rowspan=\"3\">max(min(max Sij， M iEu</td><td>maxSij） maxSij，0） 一 jEA jEQ jEp -1 -1</td></tr><tr><td>LogDetCMI</td><td>spQs</td></tr><tr><td>log</td><td>det(1-sAUpSAUP,QSAUPQ)</td></tr></table>",
+        "bbox": [
+            447,
+            223,
+            807,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The basic idea behind our framework is to exploit the relationship between the SIMs (Tab. 1) such that it can be applied to any real-world dataset. Particularly, we use the formulation of SCMI and appropriately choose a query set $\\mathcal { Q }$ and/or a conditioning set $\\mathcal { P }$ depending on the scenario at hand. Towards this end, we use the inspiration from [3] where they select data points based on diverse gradients. The SIM functions (see Tab. 2) are instantiated using similarity kernels computed using pairwise similarities $S _ { i j }$ between the gradients of the current model. Specifically, we define $S _ { i j } \\overset { = } \\langle \\nabla _ { \\theta } \\mathcal { H } _ { i } ( \\theta ) , \\nabla _ { \\theta } \\mathcal { H } _ { j } ( \\theta ) \\rangle$ , where $\\mathcal { H } _ { i } ( \\theta ) \\doteq \\mathcal { H } ( x _ { i } , y _ { i } , \\theta )$ is the loss on the $i$ th data point. Similar to [45, 3], we use hypothesized labels for computing the gradients, and the corresponding similarity kernels. The hypothesized label for each data point is assigned as the class with the maximum probability. We then optimize a SCMI function: ",
+        "bbox": [
+            173,
+            311,
+            825,
+            446
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c3a2c4be506cc489675c0a05aec6f0de2ae6365564de158ceb0286ffe3f6c247.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\scriptstyle \\mathscr { A } \\subseteq \\mathscr { U } , | \\mathscr { A } | \\leq B } I _ { f } ( \\mathscr { A } ; \\mathscr { Q } | \\mathscr { P } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            454,
+            578,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "with appropriate choices of query set $\\mathcal { Q }$ and conditioning set $\\mathcal { P }$ . In the context of batch active learning, $\\mathcal { A }$ is the batch and $B$ is the budget (batch size in AL). We present our unified AL framework in Algorithm 1 and illustrate the choices of query and conditioning set for realistic scenarios in Fig. 2. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 SIMILAR: Unified AL Framework ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            488,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Require: Initial Labeled set of data points: $\\mathcal { L }$ , large unlabeled dataset: $\\mathcal { U }$ , Loss function $\\mathcal { H }$ for learning model $\\mathcal { M }$ , batch size: $B$ , number of selection rounds: $N$   \n1: for selection round $i = 1 : N$ do   \n2: Train model $\\mathcal { M }$ with loss $\\mathcal { H }$ on the current labeled set $\\mathcal { L }$ and obtain parameters $\\theta$   \n3: Using model parameters $\\theta _ { i }$ , compute gradients using hypothesized labels $\\{ \\nabla _ { \\boldsymbol { \\theta } } \\bar { \\mathcal { H } } ( x _ { j } , \\hat { y _ { j } } , \\boldsymbol { \\theta } ) , \\bar { \\forall } j \\in \\mathcal { U } \\}$ and obtain a similarity matrix $X$ .   \n4: Instantiate a submodular function $f$ based on $X$ .   \n5: $\\begin{array} { r } { \\mathcal { A } _ { i }  \\operatorname { a r g m a x } _ { \\boldsymbol { A } \\subseteq \\mathcal { U } , | \\boldsymbol { A } | \\leq B } I _ { f } ( \\boldsymbol { A } ; \\boldsymbol { \\mathcal { Q } } | \\mathcal { P } ) } \\end{array}$ (Optimize SCMI with an appropriate choice of $\\mathcal { Q }$ and $\\mathcal { P }$ , see Tab. 1)   \n6: Get labels $L ( \\mathcal { A } _ { i } )$ for batch $\\mathbf { \\mathcal { A } } _ { i }$ and $\\mathcal { L }  \\mathcal { L } \\cup L ( A _ { i } ) , \\mathcal { U }  \\mathcal { U } - A _ { i }$   \n7: end for   \n8: Return trained model $\\mathcal { M }$ and parameters $\\theta$ . ",
+        "bbox": [
+            176,
+            563,
+            826,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the scenarios below, we will discuss how this paradigm can provide a unified view of active learning, handle aspects like standard active learning (Sec. 3.1), rare classes and imbalance (Sec. 3.2), redundancy (Sec. 3.3) and, OOD/outliers in the unlabeled data (Sec. 3.4). ",
+        "bbox": [
+            174,
+            746,
+            826,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Standard Active Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            804,
+            395,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We refer to standard active learning for ideal scenarios when there is no imbalance, redundancy or OOD data in the unlabeled dataset. In such cases, there is no requirement for having a query set and conditioning set. Hence, given a SCMI function $I _ { f } ( { \\mathcal { A } } ; { \\mathcal { Q } } | { \\mathcal { P } } )$ , we get $I _ { f } ( { \\mathcal { A } } ; { \\mathcal { Q } } | { \\mathcal { P } } ) = { \\bar { f } } ( { \\bar { \\mathcal { A } } } )$ by setting $\\mathcal { Q }  \\mathcal { U }$ (the unlabeled dataset) and $\\mathcal { P }  \\emptyset$ . In a nutshell, the standard diversified active learning setting can be seen as a special case of our proposed unified AL framework (Equ. (1)) by choosing ${ \\mathcal { Q } } , { \\mathcal { P } }$ as above. Note that this approach is very similar and closely related to BADGE [3], where the authors also choose points based on diverse gradients. Furthermore, the authors discuss the use of Determinantal Point Processes (DPP) [28] for sampling, and this is very similar to maximizing log-determinants. In the supplementary paper, we compare the choice of different submodular functions for AL. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Rare Classes ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            147,
+            302,
+            162
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A very common and naturally occurring scenario is that of imbalanced data. This imbalance is because some classes or attributes are naturally more frequently occurring than others in the realworld. For example, in a self-driving car application, there may be very few images of pedestrians at night on highways, or cyclists at night. Another example is medical imaging, where there are many rare yet important diseases (e.g., various forms of cancers), and it is often the case that non-cancerous images are much more than compared to the cancerous ones. While such classes are rare, it is also critical to be able to perform well in these classes. The problem with running standard active learning algorithms in such a case is that they may not sample too many data points from these rare classes, and as a result, the model continues to perform poorly on these classes. In such cases, we can create a (small) held-out set $\\mathcal { R }$ which contains data points from these rare classes, and try to encourage the AL by sampling more of these rare classes by maximizing the SMI function $I _ { f } ( \\mathcal { A } ; \\mathcal { R } )$ : ",
+        "bbox": [
+            173,
+            172,
+            825,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/66afbf5119514d13957f152b9416529eb989974abeef3d73eff788be220c7f1b.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\substack { A \\subseteq \\mathcal { U } , | \\mathcal { A } | \\leq B } } I _ { f } ( \\mathcal { A } ; \\mathcal { R } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            324,
+            570,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This setting is shown in Fig. 2(a). $\\mathcal { R }$ contains a small number of held-out examples of classes $5 , 8$ which are rare, and the AL acquisition function is Equ. (2). Note that this is exactly equivalent to maximizing the SCMI function with $\\mathcal { Q }  \\mathcal { R }$ and $\\mathcal { P }  \\emptyset$ (i.e. Equ. (1) in Line 5 of Algorithm 1). Furthermore, since the SMI functions naturally model query relevance and diversity, they will also try to pick a diverse set of data points which are relevant to $\\mathcal { R }$ . Finally, we also point out that this setting was considered in [15] where they use a FISHER kernel based approach to sample data points. Note that for this setting to be realistic, it is critical that the size of this validation set is very small – [15] uses a much larger validation set which is not very realistic (e.g., $2 0 0 \\times$ our set, see Appendix B for more details). ",
+        "bbox": [
+            173,
+            353,
+            826,
+            462
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Redundancy in Unlabeled Data ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            476,
+            429,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Another commonplace scenario is where we are dealing with a lot of redundancy – e.g., frames sampled from a video, where subsequent frames are visually similar. In such cases, existing AL algorithms tend to pick data points that are semantically similar to the ones selected in some earlier batch. This is true even for the state-ofthe-art AL algorithm BADGE [3] that attempts to enforce diversity, but only in the current batch of data points and not the already selected labeled set. To illustrate this, consider the scenario in Fig. 2(b). The digits $0 , 1$ are redundant in the unlabeled set, and they are already present in the labeled set $\\mathcal { L }$ . Algorithms which just focus on diversity in the current batch could fail at ensuring diversity across batches. To mitigate inter-batch redundancy, we use SCG acquisition function and condition upon the already labeled set $\\mathcal { L }$ : ",
+        "bbox": [
+            174,
+            502,
+            485,
+            755
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/4219dda3c670126460a44a616dc221db62caa0d80b9d16f53c6da493fd34be60.jpg",
+        "image_caption": [
+            "Figure 2: An illustration of realistic scenarios where SIMILAR is applied with appropriate choices of query and conditioning sets: a) SIMILAR finds rare digits $5 , 8 \\in { \\mathcal { U } }$ , by optimizing the SMI function $I _ { f } ( A ; \\mathcal { R } )$ with $\\mathcal { R }$ containing 5, 8 as queries, b) select samples from $\\mathcal { U }$ which are diverse among themselves and also diverse w.r.t those in $\\mathcal { L }$ by optimizing $f ( A | { \\mathcal { L } } )$ (here, we want to avoid digits $0 , 1 \\in \\mathcal { U }$ altogether because they are present in $\\mathcal { L }$ ), c) select digits (in-distribution) and avoid alphabets (out-of-distribution) in $\\mathcal { U }$ by optimizing $\\bar { I _ { f } } ( \\mathcal { A } ; \\mathcal { T } | \\mathcal { O } )$ , where $\\mathcal { T }$ are ID labeled points and $\\mathcal { O }$ are OOD points selected so far. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            489,
+            820,
+            694
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e488cf94d564cdf2a0d0e073528f78a33d6d1eea4aad4683935a29390428bb77.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\boldsymbol { A } \\subseteq \\mathcal { U } , | \\mathcal { A } | \\leq B } f ( \\boldsymbol { A } | \\mathcal { L } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            760,
+            395,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Notice that this is a special case of our proposed unified AL framework (Equ. (1)) since the SCG function $f ( A | { \\mathcal { L } } )$ is basically a SCMI function with $\\mathcal { Q }  \\emptyset$ and $\\mathcal { P }  \\mathcal { L }$ . ",
+        "bbox": [
+            173,
+            789,
+            483,
+            843
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Out of Distribution Data ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            383,
+            873
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "distribution (OOD) data or irrelevant classes in the unlabeled set. Such OOD data is not useful for the given classification task at hand. Using an acquisition function that selects a lot of OOD data points will lead to a waste of labeling effort and time. This is because annotators have to spend time in filtering out OOD data points and discard them from the training dataset. To account for OOD data, we add an additional class called \"OOD\" in our model. Since the goal is to improve on in-distribution classes , we ignore the prediction for the OOD class at test time. For our AL acquisition function, we use the currently labeled OOD points $\\mathcal { O }$ as the conditioning set $\\mathcal { P }$ , and the currently labeled in-distribution (ID) points $\\mathcal { T }$ as the query set $\\mathcal { Q }$ . In other words, our acquisition function is to optimize: ",
+        "bbox": [
+            171,
+            897,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ffb0cbccbf9841c8cb32f643242c71fb2683116b840ad953aca599556b8d8afe.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\substack { \\ r { A } \\subseteq \\mathcal { U } , | \\mathcal { A } | \\leq B } } I _ { f } ( \\mathcal { A } ; \\mathcal { T } | \\mathcal { O } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            186,
+            576,
+            212
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This is illustrated in Fig. 2(c), where the labeled set consists of six examples, four of them being ID data points (set $\\mathcal { T }$ ) and two being OOD data points (set $\\mathcal { O }$ ). In Fig. 2(c), the ID data are digits (digit classification) and the OOD examples are alphabets. This SCMI based approach will naturally pick points \"close\" to the ID data while avoiding the OOD points. ",
+        "bbox": [
+            174,
+            212,
+            825,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Another approach for designing the acquisition function is to not explicitly condition on the OOD data points. In other words, we can just optimize the SMI function: ",
+        "bbox": [
+            173,
+            272,
+            820,
+            300
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2741adad72ed06e7afabdd3dde7ac25ec9f73872276864b218e625940f2076cf.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\ A \\subseteq \\mathcal { U } , | \\mathcal { A } | \\leq B } I _ { f } ( \\mathcal { A } ; \\mathcal { T } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            301,
+            568,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We contrast the choices of SCMI (Equ. (4)) and SMI (Equ. (5)) functions in our experiments. ",
+        "bbox": [
+            176,
+            327,
+            781,
+            343
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.5 Multiple Co-occurring Realistic Scenarios ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            356,
+            504,
+            372
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We can also apply SIMILAR to datasets where more than one realistic scenarios are co-occurring. As illustrated in Tab. 3, we can use the formulation of SCMI and make appropriate choices of $\\mathcal { Q }$ and $\\mathcal { P }$ to tackle multiple realistic scenarios. ",
+        "bbox": [
+            176,
+            381,
+            823,
+            422
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/196452dc2207b824cd5ec3d8d0e2db29cb9a4ac4bd65b1fe725f7bb346a66f19.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Choices for $\\mathcal { Q }$ and $\\mathcal { P }$ for multiple co-occuring realistic scenarios "
+        ],
+        "table_body": "<table><tr><td>Function</td><td>Setting</td><td>Realistic Scenario</td></tr><tr><td>If(A;R|O)</td><td>Q←R,P←O Q←R,P←L-R</td><td>Rareclasses+OOD</td></tr><tr><td>If(A;RIC-R) If(A;I|OUI&#x27;)</td><td>Q←I,P←OUI&#x27;</td><td>Rare classes +Redundancy Redundancy + OOD</td></tr></table>",
+        "bbox": [
+            264,
+            433,
+            725,
+            491
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Rare classes and OOD: We set $\\mathcal { Q }  \\mathcal { R }$ and $\\mathcal { P }  \\mathcal { O }$ and maximize $I _ { f } ( { \\cal { A } } ; { \\mathcal { R } } | { \\cal { O } } )$ . Intuitively, this function would pick points close to $\\mathcal { R }$ while avoiding the OOD points. In this scenario, we can also optimize an SMI function $I _ { f } ( A ; R )$ if the data points belonging to the rare classes are not similar to the OOD data points, meaning that only searching for rare classes may suffice. Regardless, the SCMI approach above will further reinforce the avoidance of the OOD points. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Rare classes and Redundancy: We set $\\mathcal { Q }  \\mathcal { R }$ and $\\mathcal { P }  \\mathcal { L } - \\tilde { \\mathcal { R } }$ . Here, $\\tilde { \\mathcal { R } }$ is the subset of data points from the labeled set $\\mathcal { L }$ that belong to the rare classes. Intuitively, this function would pick points close to $\\mathcal { R }$ while avoiding points already in $\\mathcal { L } - \\tilde { \\mathcal { R } }$ , thereby avoiding redundant data. Just focusing on $\\mathcal { R }$ by optimizing $I _ { f } ( A ; \\mathcal { R } )$ is also a feasible option because rare classes are generally not redundant. As before, the SCMI approach will only reinforce the avoidance of redundant samples in any non-rare class instances selected. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            689
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Redundancy and OOD: This is a more challenging scenario than the ones above. We start with using the SCMI formulation for the OOD scenario, i.e., $I _ { f } ( \\mathcal { A } ; \\mathcal { T } | \\mathcal { O } )$ , where $\\mathcal { T }$ is the set of ID samples and $\\mathcal { O }$ is the set of OOD samples. Optimizing this function will pick diverse in-distribution samples within a batch. For selecting diverse samples across different batches, we can tackle this by using an appropriate kernel for the conditioning set. For instance, consider the FLCMI function in Tab. 2(b). On setting $\\mathcal { P }  \\mathcal { O } \\cup \\mathcal { I }$ , we can rewrite the FLCMI function by splitting the penalty term as follows: $\\sum _ { i \\in \\mathcal { U } } \\operatorname* { m a x } \\bigl ( \\operatorname* { m i n } ( \\operatorname* { m a x } _ { j \\in \\mathcal { A } } S _ { i j } , \\operatorname* { m a x } _ { j \\in \\mathcal { T } } S _ { i j } ) - \\operatorname* { m a x } ( \\operatorname* { m a x } _ { j \\in \\mathcal { O } } S _ { i j } , \\operatorname* { m a x } _ { j \\in \\mathcal { T } } S _ { i j } ^ { \\prime } ) , 0 \\bigr )$ . While $S$ is computed using cosine similarity, we can compute $S ^ { \\prime }$ using an exponential kernel to magnify the value of $S _ { i j } ^ { \\prime }$ using the exponent when $i$ and $j$ are very similar. This exponent is a hyperparameter which can be tuned to penalize selecting redundant samples from $I$ (denoted as $I ^ { ' }$ ) in Tab. 3. ",
+        "bbox": [
+            173,
+            694,
+            826,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.6 Realizing Realistic Scenarios in Applications ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            522,
+            873
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss a few insights on how these realistic scenarios can be realized. To begin with, the initial labeled set used in AL usually follows the distribution of the unlabeled set. The statistics of this set can be used to identify rare classes. If the initial seed set is small, the rare classes/OOD data points can be realized after a few rounds of standard AL. Until such scenarios are discovered, standard AL can be done using a diversity-based acquisition function like the log determinant (LOGDET). For production-level models, they go through a test deployment phase. During this phase, systematically recurring errors are often found. An example is of undetected bicycles at night in an object detector (false negatives). Such recurring failure cases can be due to rare classes in the labeled set. Moreover, we as users often know whether there are rare classes or if there is redundancy from domain knowledge. For instance, in the biomedical domain, images of cancer cells are typically rarer than ones of non-cancer cells because cancer inherently is a rare disease. ",
+        "bbox": [
+            174,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            213
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.7 Scalability and Computational Aspects of SIMILAR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            231,
+            568,
+            246
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Computational Complexity: The computational complexity of the different SMI functions are determined by (1) the kernel computation time, and (2) the time complexity of the greedy algorithm. All functions considered here are graph based functions and require computing a kernel matrix. The LOGDET functions (LOGDET, LOGDETMI, LOGDETCG, LOGDETCMI), some FL functions $( \\mathrm { F L }$ , FLVMI, FLCMI), and GC, GCMI all require the $n \\times n$ similarity matrix $( n = | U |$ is the number of unlabeled points) which entails a complexity of $O ( n ^ { 2 } )$ to construct the similarity kernel. Once constructed, the complexity of the greedy algorithm for LOGDET class of functions is roughly $O ( B ^ { 3 } n )$ [11], while the complexity of the greedy algorithm with FL, FLVMI, and FLCMI is $O ( B n ^ { 2 } )$ [18, 20]( $B$ is the batch size). Different from others, FLQMI does not require computing a $n \\times n$ kernel, but only a $n \\times q$ kernel (where $q = | \\mathcal { Q } |$ is the number of query points). Correspondingly, the complexity of the greedy algorithm with FLQMI is $O ( n q B )$ , and is linear in $n$ . In Appendix. A, we provide a detailed summary of the complexity of different SF, SMI, SCG, and SCMI functions. ",
+        "bbox": [
+            173,
+            257,
+            826,
+            421
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Partition Trick: The deal with the high $O ( n ^ { 2 } )$ of the LOGDET, GC, and some of the $\\mathrm { F L }$ variants (except FLQMI), we also propose the following partitioning algorithm: We randomly split the unlabeled set $\\mathcal { U }$ into $p$ partitions $\\mathcal { U } _ { 1 } , \\cdots , \\mathcal { U } _ { p }$ , and we then define the corresponding function (SF, SMI, SCMI, SCG) on each of the partitions and independently optimize them. In each partition, we select $B / p$ points. The complexity of this reduces from $O ( n ^ { 2 } )$ to $O ( n ^ { 2 } / p )$ and with an appropriate choice of $p$ , we can significantly reduce the computational complexity. We use this in our ImageNet experiments (see Sec. 4.1), and observe that our approaches continue performing well while being more scalable. We provide more details on partitioning in Appendix. A. ",
+        "bbox": [
+            173,
+            428,
+            825,
+            536
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Last Layer Gradients: Deep models have numerous parameters leading to very high dimensional gradients. Since our kernel matrix is computed using the cosine similarity of gradients, this becomes intractable for most models. To solve this problem, we use last-layer gradient approximation by representing data points using last layer gradients. BADGE [3], CORESET [40] and GLISTER [24] are other baselines that also use this approximation. Using this representation, we compute a pairwise cosine similarity matrix to instantiate acquisition functions in SIMILAR (see lines 3,4 in Algorithm 1). ",
+        "bbox": [
+            174,
+            541,
+            825,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            643,
+            385,
+            661
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we empirically evaluate the effectiveness of SIMILAR on a wide range of scenarios like rare classes (Sec. 4.1), redundancy (Sec. 4.2) and out-of-distribution (Sec. 4.3). We do so by comparing the accuracy and selections of various SCMI based acquisition functions with existing AL approaches. Using these experiments, we cover the issues with the current AL methods and show that these issues can be mitigated by using a unified implementation using SCMI with appropriate choices of query and/or conditioning sets. Although this section focuses on realistic scenarios, we also study SIMILAR in a standard active learning setting and show that it performs at par with current AL methods (see Appendix. C). Furthermore, we present some experiments on a real-world medical dataset in Appendix. H and some experiments on multiple co-occurring realistic scenarios (Sec. 3.5) in Appendix. I. ",
+        "bbox": [
+            174,
+            675,
+            825,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Baselines in all scenarios: We compare SCMI based functions against several methods. Particularly, we compare against: (1) three uncertainty based AL algorithms: i)ENTROPY: Selects the top $B$ data points with the highest entropy [41], ii) MARGIN: Select the bottom $B$ data points that have the least difference in the confidence of first and the second most probable labels [37], iii)LEAST-CONF: Select $B$ samples with the smallest predicted class probability [44], (2) state-of-the-art diversity based algorithms: iv) BADGE [3] v) GLISTER [24] vi) CORESET [40] which are all discussed in section Sec. 1.1, and, 3) RANDOM: Select $B$ samples randomly. Additionally, in the rare classes scenario, we compare against FISHER [15] which is also discussed in Sec. 1.1. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d96c65243fe1355410783da25412c46f86413f350a364b60810116b247f9ef55.jpg",
+        "image_caption": [
+            "Figure 3: Active Learning with rare classes on CIFAR-10 (top row), MNIST (middle row), and ImageNet (bottom row). Left side plots (a,d,g) are rare class accuracies, center plots (b,e,h) are overall test accuracies, right plots (c,f,i) are a number of rare class samples selected. The SMI functions (specifically LOGDETMI, FLQMI) outperform other baselines by more than $10 \\%$ on the rare classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            163,
+            87,
+            823,
+            414
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Datasets, model architecture and experimental setup: We apply our framework to CIFAR-10 [27] and MNIST [30] classification tasks. Additionally, we also evaluate our method on down sampled $3 2 \\times$ 32 ImageNet-2012 [38] for the rare classes setting (Sec. 4.1). Due to the lack of test split on ImageNet, we used the validation split for evaluation. In the sections below, we discuss the individual splits for $\\mathcal { L } , \\mathcal { U } , \\mathcal { R } , \\mathcal { Z }$ , and $\\mathcal { O }$ in each realistic scenario. To ensure that all the selection algorithms that we are studying are given fair and equal treatment across all realistic scenarios, we use a common training procedure and hyperparameters. We use standard augmentation techniques like random crop, horizontal flip followed by data normalization except for MNIST which does not use horizontal flip to preserve labels. For training, we use an SGD optimizer with an initial learning rate of 0.01, the momentum of 0.9, and a weight decay of 5e-4. We decay the learning rate using cosine annealing [31] for each epoch. On all datasets except MNIST, we train a ResNet18 [17] model, while on MNIST we train a LeNet [29] model. For all the experiments in a particular scenario (rare classes, redundancy and OOD), we start with an identical initial model $\\mathcal { M }$ and initial labeled set $\\mathcal { D }$ . We reinitialize the model parameters at the beginning of every selection round using Xavier initialization and train the model until either the training accuracy reaches $9 9 \\%$ or the epoch count reaches 150. We run each experiment $3 \\times$ on CIFAR10 and MNIST and $1 \\times$ on ImageNet and provide error bars (std deviation). All experiments were run on a V100 GPU. For more details on the experimental setup, baselines, and datasets see Appendix. B. ",
+        "bbox": [
+            173,
+            500,
+            826,
+            727
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 Rare Classes ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            738,
+            302,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Custom dataset: Following [15, 24], we simulate these rare classes by creating a class imbalance. We initialize the batch active learning experiments by creating a custom dataset which is a subset of the full dataset with the same marginal distribution. Given that $\\mathcal { C }$ consists of data points from the imbalanced classes and $\\mathcal { D }$ consists of data points from the balanced classes, we create an initial labeled set $\\mathcal { L }$ such that $| \\mathcal { D } _ { \\mathcal { L } } | = \\rho | \\mathcal { C } _ { \\mathcal { L } } |$ and an unlabeled set $| \\mathcal { D } \\boldsymbol { u } | = \\rho | \\mathcal { C } _ { \\mathcal { U } } |$ , where $\\rho$ is the imbalance factor. We use a small and clean validation/query set $\\mathcal { R }$ containing data points from the imbalanced classes $\\approx 3$ data points per imbalanced class). We create an imbalance in CIFAR-10 using 5 random classes, $\\rho = 1 0$ and for MNIST we create an imbalance using the same classes as in [15] $( 5 \\cdots 9 )$ and use $\\rho = 2 0$ . For both datasets: $| \\mathcal { C } _ { \\mathcal { L } } | + | \\mathcal { D } _ { \\mathcal { L } } | = 1 2 5$ , $| \\mathcal { C } _ { \\mathcal { U } } | + | \\mathcal { D } \\mathcal { U } | = 1 6 . 5 K$ , $B = 1 2 5$ (AL batch size) and, $| \\mathcal { R } | = 2 5$ (size of the held out rare instances). For MNIST, we also present the results for $B = 2 5$ and $\\rho = 1 0 0$ in the supplementary. On ImageNet, we randomly select 500 classes out of 1000 classes for imbalance and $\\rho = 5$ such that $| \\mathcal { C } _ { \\mathcal { L } } | + | \\mathcal { D } _ { \\mathcal { L } } | = 1 0 2 K$ , $| { \\mathcal C } _ { \\mathcal U } | + | { \\mathcal D } _ { { \\mathcal U } } | = 6 6 4 K .$ $B = 2 5 K$ and, $| \\mathcal { R } | = 2 . 5 K$ . These data splits are chosen to simulate a low initial accuracy on the rare classes and at the same time maintain the imbalance factor in the labeled and unlabeled datasets. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/05a9ef193925c2947e566d0dc0b420b7c19832834de37b0b8fc581d2fabdda87.jpg",
+        "image_caption": [
+            "Figure 4: Active Learning under $1 0 \\times$ redundancy for CIFAR-10 and MNIST. The CG functions (LOGDETCG, FLCG) pick more unique points and outperform existing algorithms including BADGE. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            161,
+            88,
+            816,
+            223
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            279,
+            823,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results: The results are shown in Fig. 3. We observe that SMI based functions not only consistently outperform uncertainty based methods (ENTROPY, LEAST-CONF and MARGIN) but also all the state-of-the-art diversity based methods (BADGE, GLISTER, CORESET) by $\\approx 5 - 1 0 \\%$ in terms of overall accuracy and $\\approx 1 0 - 1 8 \\%$ in terms of average accuracy on rare classes (see Fig. 3a, 3d, $3 \\mathrm { g }$ ). The reason for the same can be seen in Fig. 3c, 3f, 3i which illustrates that they fail to pick an adequate number of examples from the rare classes. Evidently, FLQMI and LOGDETMI which balance between diversity and relevance perform better than GCMI which only models relevance. Furthermore, DIV-GCMI which is a linear combination of GCMI and a diversity term performs consistently worse, which suggest that a naive combination of the two may not be as effective. This suggests the need of SMI based acquisitions functions (Equ. (2)) with richer modeling capabilities like FLQMI and LOGDETMI within SIMILAR. Furthermore, all SMI based functions also outperform the FISHER kernel based method when the validation set is small and realistic, i.e., $| \\mathcal { R } | = 2 5$ . Since, [15] use a very large validation set in their experiments, we try their method FISHER-LV with a $4 0 \\times$ larger validation set of size 1000 (which is not practical) and observe a comparable performance with the SMI functions which use a small validation set. Furthermore, we see that FISHER-LV actually picks significantly larger number of rare class instances in MNIST, but yet is comparable in performance of FLQMI and LOGDETMI. This suggests that both these methods select higher quality and diverse rare class instances. We observe that the GC SMI variants( GCMI and DIV-GCMI) do not perform well on MNIST classification. Finally, we point out in the case of ImageNet, FLQMI performs the best and outperforms FLVMI and LOGDETMI – this is because we do not need to do the partition trick for FLQMI since it is already linear in time complexity. For FLVMI and LOGDETMI, we set the number of partitions $p = 5 0$ for ImageNet. Finally, we do a pairwise $t { \\cdot }$ -test to compare the performance of the algorithms (Appendix. D) and observe that the SMI functions (and particularly FLVMI and LOGDETMI) statistically significantly outperform all AL baselines. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            647
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 Redundancy ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            655,
+            299,
+            670
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Custom dataset: To simulate a realistic redundancy scenario we create a custom dataset by duplicating $2 0 \\%$ of the unlabeled dataset $1 0 \\times$ . For CIFAR-10, the number of unique points in the unlabeled set $| \\mathcal { U } | = 5 K$ , the initial labeled set $| \\mathcal { L } | = 5 0 0$ , $B = 5 0 0$ , whereas for MNIST $| \\mathcal { U } | = 5 0 0$ , $| \\mathcal { L } | = 5 0$ and $B = 5 0$ . For MNIST, we also present the results for $5 \\times$ and $2 0 \\times$ in the Appendix. E. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            734
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "SCG vs Baselines: As expected, the diversity and uncertainty based methods outperform random. Importantly, we observe that the SCG functions (FLCG and LOGDETCG) significantly outperform all baselines by $\\approx 3 - 5 \\%$ towards the end as the conditioning gets stronger with increase in $\\mathcal { L }$ (see Fig. 4a, 4b). This implies that simply relying on model parameters for diversity and/or uncertainty is not sufficient and that conditioning on the updated labeled set $\\mathcal { L }$ (Equ. (3)) is required in batch active learning. In Fig. 4c we show that SCG based acquisition functions select significantly more unique data points than other baselines. We also perform a pairwise t-test (Appendix. E), to prove that the SCG functions consistently and statistically significantly outperform BADGE and other baselines. ",
+        "bbox": [
+            174,
+            741,
+            825,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Out-Of-Distribution ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            354,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Custom dataset: We simulated a scenario where we convert the classification problem in CIFAR-10 and MNIST to a 8-class classification, where the first 8 classes represent the set $\\mathcal { T } _ { F }$ of in-distribution (ID) data points and the last 2 represent the set ${ \\mathcal { O } } _ { F }$ of out-of-distribution(OOD) data points. The initial labeled set $\\mathcal { L }$ consists only of $\\mathit { I D }$ points, i.e. $\\mathcal { O } _ { F } \\cap \\mathcal { L } = \\emptyset$ . The unlabeled set is simulated to reflect a realistic and somewhat extreme setting where the unlabeled ID data points $| \\mathcal { T } _ { F } |$ is much smaller than the unlabeled OOD data points $| \\mathcal { O } _ { F } |$ . Additionally, we also assume we have a very small validation set of ID points $\\mathcal { T } _ { V }$ . For CIFAR-10: $| \\mathcal { L } | = 1 . 6 K$ , $\\vert \\mathcal { I } _ { F } \\vert = 4 K$ , $| \\mathcal { O } _ { F } | = 1 0 K$ , $\\vert \\mathcal { T } _ { V } \\vert = 4 0$ , $B = 2 5 0$ whereas for MNIST which is a relatively simpler task, we use a smaller initial labeled sets and keep the unlabeled sets of the same size: $| { \\mathcal { L } } | = 4 0$ , $| \\mathcal { T } _ { F } | = 4 0 0$ , $| \\mathcal { O } _ { F } | = 1 0 K$ , $\\vert \\mathcal { I } _ { V } \\vert = 1 6$ , $B = 2 0$ . Recall that our algorithm uses ID set $\\mathcal { T }$ (initialized to $\\mathcal { T } _ { V }$ ) and OOD set $\\mathcal { O }$ which we build as follows. Every time our selection approach selects a set $\\mathcal { A }$ , we update $\\mathcal { T } = \\mathcal { T } \\cup ( \\mathcal { A } \\cap \\mathcal { Z } _ { F } )$ and $\\mathcal { O } = \\mathcal { O } \\cup ( \\mathcal { A } \\cap \\dot { \\mathcal { O } } _ { F } )$ , i.e. we augment the ID and OOD points in $\\mathcal { A }$ to the sets $\\mathcal { T }$ and $\\mathcal { O }$ respectively. ",
+        "bbox": [
+            174,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4bffb5fa27c18c0f868a213e025142d64bff0fdad1ad9dd3783d48852fbccbf.jpg",
+        "image_caption": [
+            "Figure 5: Active Learning with OOD data in unlabeled set. Top row: CIFAR-10 results for (a) SCMI vs Baselines, (b) SCMI vs SMI, and (c) variance comparison of different baselines, bottom row: MNIST results for (d) SCMI vs Baselines, (e) SCMI vs SMI, and (f) Number of ID points selected. We see that, i) the SCMI functions consistently outperform the baselines by $5 \\% - \\ \\mathrm { \\bar { 1 0 \\% } }$ , ii) SCMI functions outperform the corresponding SMI functions for later rounds, and (iii) SCMI functions have the least variance compared to the rest, showing that they are more robust in performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            163,
+            88,
+            823,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            419,
+            825,
+            555
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "SCMI vs Baselines: Since we care about the predictive performance of the ID classes, we report the ID classes accuracy. We see that SCMI based acquisition functions significantly outperform existing AL approaches by $\\approx 5 - 1 0 \\%$ (see Fig. 5a, 5d). We also observe that existing acquisition functions have a high variance, which is undesirable in real-world deployment scenarios where deep models are being continuously developed. Our SCMI based acquisition functions (LOGDETCMI and FLCMI) show the lowest variance in training (see Fig. 5c). This reinforces the need of having a framework like SIMILAR that facilitates query and conditioning sets. ",
+        "bbox": [
+            174,
+            560,
+            825,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "SCMI vs SMI: We compare SCMI functions against SMI functions to study the effect of conditioning and observe that the SCMI functions are comparable to the SMI functions initially but in the later selection rounds of active learning, the SCMI functions consistently outperform SMI functions. In particular, we see an improvement of $2 - 3 \\%$ as the conditioning becomes stronger (see Fig. 5b, 5e). We also observe the SCMI tends to select more ID points than SMI and other baselines (see Fig. 5f), and SCMI functions have a lower variance overall compared to even the SMI functions (Fig. 5c). ",
+        "bbox": [
+            174,
+            660,
+            825,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            299,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we proposed a unified active learning framework SIMILAR using the submodular information functions. We showed the applicability of the framework in three realistic scenarios for active learning, namely rare classes, redundancy, and out of distribution data. In each case, we observed that the functions in SIMILAR significantly outperform existing baselines in each of these tasks. Our real-world experiments on MNIST, CIFAR-10, and ImageNet show that many of the SIM functions (specifically the LOGDET and FL variants) yield $\\approx \\mathrm { \\tilde { 5 } \\% } - 1 8 \\%$ gain compared to existing baselines, particularly in the rare class scenario and $\\ddot { \\approx } 5 \\% - 1 0 \\%$ OOD scenarios. The main limitations of our work is the dependence on good representations to compute similarity. A potential negative societal impact of this work is the use of SIMILAR to perpetuate certain biases through a malicious use of the query and conditioning set. We discuss this in more detail in Appendix. G. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work is supported by the National Science Foundation under Grant No. IIS-2106937, a startup grant from UT Dallas, and by a Google and Adobe research award. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the National Science Foundation, Google or Adobe. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            175
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            195,
+            266,
+            212
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Sami Abu-El-Haija, Nisarg Kothari, Joonseok Lee, Paul Natsev, George Toderici, Balakrishnan Varadarajan, and Sudheendra Vijayanarasimhan. Youtube-8m: A large-scale video classification benchmark. arXiv preprint arXiv:1609.08675, 2016.   \n[2] David Arthur and Sergei Vassilvitskii. k-means $^ { + + }$ : the advantages of careful seeding. In SODA ’07: Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete algorithms, pages 1027–1035, Philadelphia, PA, USA, 2007. Society for Industrial and Applied Mathematics. ISBN 978-0-898716-24-5.   \n[3] Jordan T Ash, Chicheng Zhang, Akshay Krishnamurthy, John Langford, and Alekh Agarwal. Deep batch active learning by diverse, uncertain gradient lower bounds. arXiv preprint arXiv:1906.03671, 2019.   \n[4] Francis Bach. Learning with submodular functions: A convex optimization perspective. arXiv preprint arXiv:1111.6453, 2011.   \n[5] Francis Bach. Submodular functions: from discrete to continuous domains. Mathematical Programming, 175(1):419–459, 2019.   \n[6] Christopher Berlind and Ruth Urner. Active nearest neighbors in changing environments. In International Conference on Machine Learning, pages 1870–1879. PMLR, 2015.   \n[7] Joy Buolamwini and Timnit Gebru. Gender shades: Intersectional accuracy disparities in commercial gender classification. In Conference on fairness, accountability and transparency, pages 77–91. PMLR, 2018.   \n[8] Holger Caesar, Varun Bankiti, Alex H Lang, Sourabh Vora, Venice Erin Liong, Qiang Xu, Anush Krishnan, Yu Pan, Giancarlo Baldan, and Oscar Beijbom. nuscenes: A multimodal dataset for autonomous driving. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 11621–11631, 2020.   \n[9] Colin Campbell, Nello Cristianini, Alex Smola, et al. Query learning with large margin classifiers. In ICML, volume 20, page 0, 2000.   \n[10] Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling. arXiv preprint arXiv:1312.3005, 2013.   \n[11] Laming Chen, Guoxin Zhang, and Hanning Zhou. Fast greedy map inference for determinantal point process to improve recommendation diversity. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pages 5627–5638, 2018.   \n[12] Shai Fine, Ran Gilad-Bachrach, and Eli Shamir. Query by committee, linear separation and random walks. Theoretical Computer Science, 284(1):25–51, 2002.   \n[13] Yoav Freund, H Sebastian Seung, Eli Shamir, and Naftali Tishby. Selective sampling using the query by committee algorithm. Machine learning, 28(2):133–168, 1997.   \n[14] Satoru Fujishige. Submodular functions and optimization. Elsevier, 2005.   \n[15] Denis Gudovskiy, Alec Hodgkinson, Takuya Yamaguchi, and Sotaro Tsukizawa. Deep active learning for biased datasets via fisher kernel self-supervision. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9041–9049, 2020.   \n[16] Anupam Gupta and Roie Levin. The online submodular cover problem. In ACM-SIAM Symposium on Discrete Algorithms, 2020.   \n[17] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.   \n[18] Rishabh Iyer and Jeffrey Bilmes. A memoization framework for scaling submodular optimization to large scale problems. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 2340–2349. PMLR, 2019.   \n[19] Rishabh Iyer, Ninad Khargoankar, Jeff Bilmes, and Himanshu Asanani. Submodular combinatorial information measures with applications in machine learning. In Algorithmic Learning Theory, pages 722–754. PMLR, 2021.   \n[20] Rishabh Krishnan Iyer. Submodular optimization and machine learning: Theoretical results, unifying and scalable algorithms, and applications. PhD thesis, 2015.   \n[21] Kimmo Karkkainen and Jungseock Joo. Fairface: Face attribute dataset for balanced race, gender, and age for bias measurement and mitigation. In Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision, pages 1548–1558, 2021.   \n[22] Vishal Kaushal, Rishabh Iyer, Suraj Kothawade, Rohan Mahadev, Khoshrav Doctor, and Ganesh Ramakrishnan. Learning from less data: A unified data subset selection and active learning framework for computer vision. In 2019 IEEE Winter Conference on Applications of Computer Vision (WACV), pages 1289–1299. IEEE, 2019.   \n[23] Vishal Kaushal, Suraj Kothawade, Ganesh Ramakrishnan, Jeff Bilmes, and Rishabh Iyer. Prism: A unified framework of parameterized submodular information measures for targeted data subset selection and summarization. arXiv preprint arXiv:2103.00128, 2021.   \n[24] Krishnateja Killamsetty, Durga Sivasubramanian, Ganesh Ramakrishnan, and Rishabh Iyer. Glister: Generalization based data subset selection for efficient and robust learning. arXiv preprint arXiv:2012.10630, 2020.   \n[25] Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   \n[26] Andreas Kirsch, Joost Van Amersfoort, and Yarin Gal. Batchbald: Efficient and diverse batch acquisition for deep bayesian active learning. arXiv preprint arXiv:1906.08158, 2019.   \n[27] Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.   \n[28] Alex Kulesza and Ben Taskar. Determinantal point processes for machine learning. arXiv preprint arXiv:1207.6083, 2012.   \n[29] Yann LeCun, Bernhard Boser, John S Denker, Donnie Henderson, Richard E Howard, Wayne Hubbard, and Lawrence D Jackel. Backpropagation applied to handwritten zip code recognition. Neural computation, 1(4):541–551, 1989.   \n[30] Yann LeCun, Corinna Cortes, and CJ Burges. Mnist handwritten digit database. at&t labs, 2010.   \n[31] Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint arXiv:1608.03983, 2016.   \n[32] Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, Ian Goodfellow, and Brendan Frey. Adversarial autoencoders. arXiv preprint arXiv:1511.05644, 2015.   \n[33] Baharan Mirzasoleiman, Ashwinkumar Badanidiyuru, Amin Karbasi, Jan Vondrák, and Andreas Krause. Lazier than lazy greedy. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 29, 2015.   \n[34] George L Nemhauser, Laurence A Wolsey, and Marshall L Fisher. An analysis of approximations for maximizing submodular set functions—i. Mathematical programming, 14(1):265–294, 1978.   \n[35] Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. 2011.   \n[36] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Kopf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, highperformance deep learning library. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems 32, pages 8024–8035. Curran Associates, Inc., 2019. URL http://papers.neurips.cc/paper/ 9015-pytorch-an-imperative-style-high-performance-deep-learning-library. pdf.   \n[37] Dan Roth and Kevin Small. Margin-based active learning for structured output spaces. In European Conference on Machine Learning, pages 413–424. Springer, 2006.   \n[38] Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.   \n[39] Greg Schohn and David Cohn. Less is more: Active learning with support vector machines. In ICML, volume 2, page 6. Citeseer, 2000.   \n[40] Ozan Sener and Silvio Savarese. Active learning for convolutional neural networks: A core-set approach. arXiv preprint arXiv:1708.00489, 2017.   \n[41] Burr Settles. Active learning literature survey. 2009.   \n[42] Samarth Sinha, Sayna Ebrahimi, and Trevor Darrell. Variational adversarial active learning. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5972–5981, 2019.   \n[43] Ehsan Tohidi, Rouhollah Amiri, Mario Coutino, David Gesbert, Geert Leus, and Amin Karbasi. Submodularity in action: From machine learning to signal processing applications. IEEE Signal Processing Magazine, 37(5):120–133, 2020.   \n[44] Dan Wang and Yi Shang. A new active labeling method for deep learning. In 2014 International joint conference on neural networks (IJCNN), pages 112–119. IEEE, 2014.   \n[45] Kai Wei, Rishabh Iyer, and Jeff Bilmes. Submodularity in data subset selection and active learning. In International Conference on Machine Learning, pages 1954–1963. PMLR, 2015.   \n[46] Xiang Zhang, Junbo Zhao, and Yann LeCun. Character-level convolutional networks for text classification. arXiv preprint arXiv:1509.01626, 2015.   \n[47] Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In Proceedings of the IEEE international conference on computer vision, pages 19–27, 2015. ",
+        "bbox": [
+            176,
+            220,
+            826,
+            910
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            60,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            493
+        ],
+        "page_idx": 12
+    }
+]