{'fraction_non_alphanumeric': 0.04136690647482014, 'fraction_numerical': 0.019527235354573486, 'mean_word_length': 4.587116454333393, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Approximated Bilinear Modules for Temporal Modeling

We consider two less-emphasized temporal properties of video: 1. Temporal cues are fine-grained; 2. Temporal modeling needs reasoning. To tackle both problems at once, we exploit approximated bilinear modules (ABMs) for temporal modeling. There are two main points making the modules effective: two-layer MLPs can be seen as a constraint approximation of bilinear operations, thus can be used to construct deep ABMs in existing CNNs while reusing pretrained parameters; frame features can be divided into static and dynamic parts because of visual repetition in adjacent frames, which enables temporal modeling to be more efficient. Multiple ABM variants and implementations are investigated, from high performance to high efficiency. Specifically, we show how two-layer subnets in CNNs can be converted to temporal bilinear modules by adding an auxiliary-branch. Besides, we introduce snippet sampling and shifting inference to boost sparse-frame video classification performance. Extensive ablation studies are conducted to show the effectiveness of proposed techniques. Our models can outperform most state-of-the-art methods on Something-Something v1 and v2 datasets without Kinetics pretraining, and are also competitive on other YouTube-like action recognition datasets. Our code is available on https://github.com/zhuxinqimac/abm-pytorch.


Introduction
Video action recognition has been one of the most fundamental problems in computer vision for decades. Since CNNs achieved great success in image classification [23,36,40,16,17], deep models have been introduced to video domain for action recognition [18,35,6,42,47,38,8,48]. Different from image classification, video action recognition requires effort for temporal modeling, which is still an open problem in this field.
Up to now there have been three promising ways for temporal modeling in action recognition. The first one is twostream architecture [35,9,47] where the temporal information is captured by optical flow (can cost over 90% of the run time [39]). The second one is 3D CNN [18,42,43,2]. This methods has the problem of high pretraining cost because 3D CNNs are hard to be directly used for small datasets due to overfitting. This pretraining can be very expensive, e.g. 64 GPUs used in [2] and 56 GPUs used in [51]. A late fusion step is usually used along with the above two methods for long-term prediction, which slowdowns their inference again. We refer the above two methods as heavy methods. On the contrary, the third way is a light method which conducts temporal modeling based on 2D backbones where input frames are usually sparsely sampled [6,32,31,34,55,54,27]. Without expensive late fusion, preprocessing and postprocessing computational overheads are eliminated. We value these merits of light architectures, and discover a very powerful module which works harmoniously and effectively with them. Addtionally, the module we propose is very flexible and can also work with heavy methods to get an evident performance boost. This paper is based on our two discoveries about videos. The first one is: Temporal cues are fine-grained. Here we refer fine-grained since the temporal information (motion or state changes) could be easily dominated by spatial information (color blobs). This property can explain the usage of optical flow [35] or dense trajectory [45] which magnify the impact of temporal features by extracting them explicitly. As bilinear models have been shown effective for fine-graind classification [29,28], it motivates us to bring bilinear operation to video temporal modeling. The second discovery is: Temporal modeling needs reasoning. Unlike image processing where low-level features like texture or color blobs are crucial for classification, the key features in time could be more high-level and reasoning-required, e.g. basic physics, causality, and human's intention. As the state-of-the-art technique for VQA problem which requires textual and visual reasoning is bilinear model [10,21,53], it again inspires us to use bilinear model to do reasoning for temporal sequences.
Based on the discoveries above, we introduce our Approximated Bilinear Modules (ABMs) for temporal modeling. There are two insights that make ABMs effective. The first is that two-layer MLPs can be seen as a constrained approximation of bilinear operations, which enables us to flexibly construct ABMs inside existing deep networks while reusing pretrained parameters. The second is that adjacent frames are likely to be repetitive, so we propose to represent a frame feature with static and dynamic parts to achieve a more efficient computation. We investigate the module's multiple temporal variants, and how they can work with CNNs smoothly. Particularly, we introduce how ABMs can be carefully initialized so that they can be implanted into deep architectures while keeping pretrained parameters valid. In this paper, our proposed modules are instantiated with two backbones (2D-ResNet-34 and I3D) to show 1. the pure power of ABMs for temporal modeling, and 2. the complementarity with 3D networks. Besides, we also present a flow-inspired snippet sampling to bring shortterm dynamics to light models, and also introduce a shifting inference protocol to further boost performance. Our models can outperform most previous state-of-the-art methods on Something-Something v1 and v2 datasets without large video dataset pretraining such as Kinetics, while keeping a decent accuracy-speed tradeoff.

Related Work
Deep Learning for Action Recognition. Nowadays deep neural networks have been popular for video action recognition [19,35,18,42,46,6,32,47,2,54]. Karpathy et al. investigated deep models with various temporal fusion strategies on Sports-1M dataset [19]. Ji et al. proposed 3D CNNs for end-to-end action recognition [18], and this idea has been extended to more general feature representation learning by C3D [42]. Later, more powerful and deeper 3D CNNs with variations have been introduced, such as Res3D [43], I3D [2] (using inflated ImageNet-pretrained parameters), S3D [51] (looking for cheaper 3D convolutions), and ARTNet [46]. Usually 3D architectures are heavy and reuqire expensive pretraining. Two-Stream architecture [35] utilizes pre-extracted optical flow to capture temporal information. Feichtenhofer et al. investigated different fusion methods to more efficiently conduct twostream processing [9]. For long-term temporal modeling, Donahue et al. [6], Ng et al. [32] and Shi et al. [34] adopted LSTMs in video action recognition. Later, Ballas et al. [1] proposed a ConvGRU for video understanding using multilayer feature maps as inputs. Later Wang et al. [47] proposed TSN architecture for long-term modeling, which is popular in 3D-based methods. Recently some works fo-cus on light-weight temporal modeling. Zhou et al. [54] to do late reasoning in action recognition. Zolfaghari et al. [55] introduced ECO, a hybrid architecture of BN-Inception and 3D-ResNet-18 for fast action recognition. By shifting part of feature vectors, Lin et al. [27] proposed TSM to do temporal modeling without extra parameters. Our work is to implant the bilinear operations into normal convolutions, with the goal of exploiting the fine-grained nature of temporal dynamics, while reusing the normal pretrained parameters as well.
Bilinear Models. Bilinear pooling has been promising in many computer vision tasks [29,11,10,21,53,28,52,12] Lin et al. utilized two streams of CNNs for finegrained classification by extracting two branches of features and fusing them with outer product [29]. To address the high-dimension problem of bilinear pooling, Gao et al. introduced compact bilinear pooling [11] where the projected low-dimensional feature's kernel approximates the original polynomial kernel. In VQA tasks where inputs are naturally bi-modal, bilinear models are shown very effective [10,21,53]. Kim et al. [21] brought bilinear low-rank approximation [33] to VQA, and Yu et al. [53] proposed a rank-n variant. The bilinear operation has also been shown effective to pool over hierarchical layers in CNNs [52].
There have been some attempts to apply bilinear approaches to video action recognition [5,50,13]. Diba et al. [5] proposed Temporal Linear Encoding (TLE) to encode a video into a compact representation using compact bilinear pooling [11]. Wang et al. [50] introduced a spatiotemporal pyramid architecture using compact bilinear pooling to fuse temporal and spatial information with attention. In [13], a top-down attention model has been developed based on the rank-1 approximation of bilinear pooling operation. However, these attempts either apply the bilinear operations to spatial features or fuse multiple branches of modalities, but none show its potential for temporal modeling.

Approach
We first give definitions of ABM with variants, then introduce how they can work with deep architectures smoothly. Later we present two instantiations of our modules, snippet sampling, and implementation details.

General Approximated Bilinear Module
Definition. A bilinear pooling module [41,29] calculates the Gram matrix of two global descriptors to learn a pair-wised relation feature. In this paper, we ignore the pool-over-location operation in bilinear pooling, but focus on the simpler bilinear module taking two vectors as inputs: where z ∈ R D is the output vector, and function V ec( ) vectorizes a matrix.
x ∈ R C and y ∈ R C denotes two input vectors each containing C channels. W ∈ R D×CC is the learnable parameters. As the number of parameters of this naive bilinear module is too large for widely usage [11,21,53], we factorize each element w kij in weight W ∈ R D×C×C by three smaller matrices: w kij = R r=1 u kr a ir b jr , where (u kr ) = u ∈ R D×R , (a ir ) = a ∈ R C×R , (b jr ) = b ∈ R C ×R are factorized parameters. Then the General Approximated Bilinear Module (ABM-G, Fig. 1 (a)) can be defined as: where • denotes element-wise product. There are many variants of this form exploited in various applications [21,53,30,46], and all of them can be derived from this general form by substituting some specific elements. Relation to Two-Layer MLP. For Eq. 3, if we fix b T y = 1 and add a nonlinear layer in the middle [21], the ABM-G becomes a two-layer MLP. From this viewpoint, a two-layer MLP can be seen as a constrained approximation of the bilinear module, whose bilinear weights are factorized in a constrained way: w kij = R r=1 u kr a ir b jr , where C j=1 b jr y j = 1, with an additional activation layer for keeping nonlinearity. This constraint just ignores information from y thus no bilinear features are learned. Because of this negative effect, we refer this branch outputting 1 as constrained-branch. Reversely, if we free a two-layer MLP from this constraint by making the weights in the constrained-branch tunable, then the freed MLP, which is now ABM-G with an additional nonlinearity layer, can learn a bilinear feature rather than the original linear feature, and we name this tunable branch auxiliary-branch. This transformation enables a pathway to enhance the traditional twolayer MLPs to be more discriminative, which is also the key technique how we implant the ABMs into CNNs' intermediate layers (Sec. 3.3), while reusing the pretrained weights.

Temporal ABMs
Unlike other bilinear applications where inputs usually comes in duel forms, e.g. two branches [29,11], two modalities [10,21,53,50], it is not very straightforward to apply bilinear modules to temporal problems. We consider several variants for temporal modeling. The frame features along time are denoted as {x 1 , x 2 , .., x t , ..}.
ABM-S. First we consider simply feeding adjacent frame features to ABM-G's two entries separately: z = ABM g (x t , x t+1 ). This is the most straightforward way and easy to implement. We name it ABM-S (see Fig. 1 (b)). The potential drawbacks of this variant are: 1. its temporal receptive field is limited since it can only perceive two frames at once; 2. it lacks self-bilinear capability which is shown effective for classification in some cases [22,25,5]. We propose ABM-C to solve these problems.
ABM-C. We consider a second way to feed a concatenation of multiple frames into both ABM entries: where m denotes the number of concatenated frames. We name this module ABM-C (see Fig. 1 (c)). This variant can perceive more frames at once and it is similar to naive convolution so it is easier to work with existing CNNs. In this paper, we fix m = 3. We show that ABM-C is more effective than ABM-S in the experiments (Sec. 4.2). A potential problem of this module is its massive parameters since its parameter number grows linearly with the perceived frames.
To diminish this problem, we propose ABM-A. ABM-A. We consider an intrinsic property of videos: repetition. For most time, adjacent frames come with duplicated visual information, and the dynamics in them that defines the motion of a video is very subtle and fine-grained. Therefore we propose to divide a single frame descriptor into two parts: (a) A normal two-layer network. Red-stripe areas denote pretrained parameters.
(b) An ABM-A constructed out of the two-layer network (a), reusing the parameters, perceiving adjacent frames.  Figure 2. dynamic part is more discriminative for temporal modeling.
Based on this intuition, we define the Adjacent Approximated Bilinear Module (ABM-A): See Fig. 1 |xt| ∈ [0, 1] as a hyper-parameter. When β = 0, the module becomes purely frame-level and conducts no temporal modeling; when β = 1, the module is equal to ABM-C for full temporal modeling. We investigate β = 1 2 and 1 4 in the experiments (Sec. 4.2).

Exploiting Deep Architectures
We are committed to develop our modules to be general and flexible enough so that it not only can work in a plug-and-play manner, but also can enjoy the pretraining of deep architectures. In this subsection we introduce how our ABM modules can work with existing deep CNNs, while reusing the pretrained parameters.
On Top of CNNs. The most straightforward way is to put our modules on top of deep CNNs so that the backbone is not interfered and all pretrained parameters could be intact. We stack multiple layers of ABM modules to increase the temporal receptive fields and capture more complex temporal nonlinearity. This model conducts all temporal modeling at the high-semantic level which can lead to a very high-speed inference. In this case, ABM parameters can be initialized randomly which is easy to implement. We compare this implementation with various post-CNN temporal pooling methods [5,47,54] using a same backbone network with same configurations to fairly show our models' effectiveness. However this implementation has some problems: 1. since the ABMs are all initialized randomly and contain element-wise multiplications, it could not go too deep or may lead to convergence difficulty and slow down the training; 2. because of the first problem, it could not have a large temporal receptive field, leading to limited temporal modeling capability.
Implanted into CNNs. Additionally, we consider a more flexible way: implanting ABMs into deep architectures's intermediate layers. As we show in Sec. 3.1 that MLPs could be seen as a constrained approximation of bilinear operations, we could also reversely transform twolayer convolutions of CNNs into ABMs by constructing an auxiliary-branch with tunable weights.
Let's assume we want to build an ABM-A module out of two convolutional layers ( Fig. 2 (a)), which should be quite common in deep CNN architectures. Firstly we retain the first convolution Conv1 (see x t → o t in Fig. 2 (a) and (b)). Secondly we construct its sibling operation Conv2 (see x t → o t in Fig. 2 (b)), containing the same input and output dimensions as Conv1. Then we initialize all its weights to be 0, and the corresponding bias to be 1 so that initially whatever the input is, the output of Conv2 is 1. By taking the above two steps, we have manually constructed the auxiliary-branch (b T y = 1, see Sec. 3.1 for explanation). This guarantees that: Conv1(x) • Conv2(y) = Conv1(x), meaning the original pathway in the CNN is intact, therefore the pretrained parameters are still valid. By freeing the weights in the auxiliary-branch, we get an ABM-G whose initial power is the same as the original two-layer network.
If the original CNN is a 2D network (e.g. pretrained on ImageNet), we also need to adapt it for temporal modeling. In this case, the input of Conv1 and Conv2 is expanded to perceive surrounding frame features. How the expansion happens depends on the type of ABM in used here, e.g. for ABM-A/C, we need to incorporate the dynamic feature parts of adjacent frames; for ABM-S, two branches take two neighbored frames as inputs separately. However only the weights corresponding to the current frame are initialized with pretrained parameters while others are set to be zeros (cyan areas in Fig. 2 (b)). This modification also does not change the behavior of the origional 2D network so the pretrained parameters are still valid (red-stripe areas in Fig. 2 (b) denote the original CNN pathway with pretrained parameters). Together with the second convolution layer (see o t → z t in Fig. 2 (b), which is also o t → z t in Fig. 2 (a)), we built an ABM-A out of pretrained twolayer convolutions with all parameters preserved, based on the idea that freeing the auxiliary-branch to be tunable. If the origional CNN is already 3D, we can construct ABM-C modules by just adding the auxiliary-branch with initialization of W = 0, b = 1. By implanting ABMs into CNNs with careful initializations, the ABMs can be stacked very deeply with temporal receptive fields becoming very large.
Network Instantiations. We instantiate our proposed modules with two architectures: 2D-ResNet-34 [16] and I3D [2]. The 2D-ResNet-34 backbone is used to show the true power of ABMs for temporal modeling. This backbone is pure 2D and pretrained on ImageNet dataset [4] for image classification without any prior knowledge about temporal information. The I3D backbone is used to show the complementarity between our ABMs and the state-of-theart 3D architecture. It is pretrained on Kinetics dataset [20] for action recognition.
For 2D-ResNet-34, we implant ABMs into each nondown-sampling residual blocks for block-layer 2, 3, and 4. In each block, there are two convolutional layers which is perfect for ABMs' construction. Following last section, we can add a tunable auxiliary-branch and expand the temporal receptive field to build ABM modules (see Fig. 2 (c)). We add a kernel-2 stride-2 temporal maxpooling layer after block-layer 2 for more efficient computation.
For I3D, we build ABMs aside the larger 3 × 3 × 3 convolution in each Inception block after layer-3c (see Fig. 2 (d)). Though there is no appended layer to form a complete ABM in a single Inception block, by taking into account the next Inception block the ABM is still complete.

Snippet Sampling
In [54,55,27], sparse sampling is used for efficient video processing. Specifically, they divide each video into N segments and sample a single frame from each. We generally follow this strategy, but also argue that only sampling a single frame per segment discards too much useful short-term information in consecutive frames. Instead, we borrow a strategy from optical flow sampling [35], which each time samples a short snippet (containing K frames) rather than only a single frame. To keep efficiency of sparse sampling, only the weights in the first convolutional layer are duplicated to perceive the snippet, while rest of the network still feels it is processing N single frames. In this paper, we choose N = 8 or 16, and fix K = 3 after ablation study. Snippet sampling is represented by N × K in tables.

Implementation Details
Training. For inputs, we randomly sample a snippet in each segment for 2D-ResNet-34 models, and densely sample 64 frames for I3D models. The input frames are scaled to 256 × 256 and randomly cropped to 224 × 224. For Something-Something v1 and v2 datasets, we use 2D-ResNet-34 backbone pretrained on ImageNet to show the pure effectiveness of our modules' temporal modeling; for other datasets, we use I3D backbone pretrained on Kinetics. We train all models using SGD with momentum of 0.9. All models are trained or fine-tuned with 0.001 initial learning rate and decayed by 10 twice. Testing. During testing of 2D-ResNet-34-based models, we sample the center snippet for each segment to do the inference. We also introduce a new testing protocol by shifting the snippets so that more frames are used in a segment. We define shifting-time ST , so shifted samples of a video will be used for inference, and the output of a video will be the averaged output of each shifted sample. To calculate the shifting-offset, we divide each segment by ST . In this paper, we fix ST = 3, and we will specify if shifting inference is used in the experiments. For I3D-based models, center 150 frames are used for inference. During validation and testing, the video frames are scaled to 224 × 224 then fed to models. No other cropping strategies are used.

Experiments
We perform comprehensive ablation studies on Something-v1 dataset [14]. Then we compare our models with state-of-the-art methods on various datasets, while showing our models' generality to optical flow modality. Efficiency analysis and visualization are also provided.

Datasets
Something-Something v1 [14] and v2 [31] are crowdsourced datasets focusing on temporal modeling, containing fine-grained human motions and human-object interactions. There are 108,499 videos in v1 and 220,847 videos in v2, with 174 categories in each dataset. Besides, other YouTube-like datasets, Kinetics [20], UCF101 [37], and HMDB51 [24], are also used to validate our models on action recognition. These three datasets contain more static-   recognizable categories thus spatial modeling could be as crucial as temporal modeling. The latter two sets are smallscale so Kinetics-pretraining is used.

Ablation Study on Something-v1
Top-of-CNN Effectivsness. We first conduct experiments with On Top of CNNs structure using 8-frame sampling. No shifting inference is used. Results are shown in Table 1. For comparison, we reimplement several existing post-CNN temporal models: 1. Avg Pooling or naive version of TSN [47]; 2. TRN [54]; 3. Compact Bilinear Pooling [11,5]. To calculate VPS (video per second), we do val-idation on a single GeForce GTX TITAN X with fixed batch size of 8, and discard the first 200 iterations to calculate a stable VPS. We can see the ABM-S-top models, which perceive neighbored frames seperately by two branchs, are not very effective even we increase the ABM-S layers to 3. On the other hand, ABM-C-top models, whose both branches perceive concatenated frames, are very effective and can enjoy lots of gain from more layers.
Does Snippet Sampling Work? We show the effect of snippet sampling by increasing snippet length from 1 to 3 on ABM-C-top L=3. Results are in Table 1 bottom. There is an obvious gain when snippet length is increased by just a small number, e.g. 4% boost from K = 1 to K = 3 while the inference time is almost not affected. This is because the additional calculation only comes from the first convolutional layer. However if a snippet is longer than 3, the data loading time will surpass the inference time, slowing down the training, so the snippet length is not further increased.
How to work with CNNs? In Table 2 first half, we compare On Top of CNNs (denoted by top) and Implanted into CNNs (denoted by in) frameworks. We see the top model can run at a very high inference speed, while the in model can achieve higher performance. But in Fig. 3 we can see the top model converges much slower. This is due to the better initialization of in models. Also there is a little training difficulty at the beginning of ABM-C-top, which is more obvious when layers are over 4. Therefore we prefer to use ABMs by implanting them into CNNs, but the top models are more useful when inference speed is a main concern.
In Table 2 second half, we compare ABM-A models and ABM-C models. An ABM-A becomes ABM-C when β = 1. We can see β controls the speed-accuracy tradeoff when it is shifting, but accuracy seems to be very similar between β = 1/2 and β = 1. We consider ABM-A with β = 1/2 as a model with balanced performance and efficiency.
Does Shifting Inference Work? In Table 3, we see shifting inference can boost all model variants by around 0.7%. The shift-time is fixed to 3. We use this testing protocol in the state-of-the-art comparison.

Comparison with State-of-the-Art
We compare our ABM models with other state-of-theart methods on Something-v1 and v2 datasets since these two datasets focus on temporal modeling. Our ImageNetpretrained ABM models can outperform most other methods, showing high effectiveness for temporal modeling.
RGB Models. In the first half section of Table 4, we compare state-of-the-art RGB models. The only models that have the same pretraining setting as ours are Multi-Scale TRN [54] and a baseline model 3D-VGG-LSTM [31]. Under this setting, the two methods can only achive very limited performance, outperformed by ours by about 10% of accuracy on both sets. With the pretraining of Kinet-  ics dataset, ECO-Lite En [55], NL I3D+GCN [49], and TSM En [27] can obtain competitive performance, using deeper backbone architectures. Besides their heavier pretraining, two of these methods are ensemble models and the other one reqires an MSCOCO pretrained Regional Proposal Network, which lead to an unfair comparison. However, despite the weaker configurations, our single model can still outperform all of them on the v1 validation set (acc 46.81% with ResNet-34), and our ensemble model (ABM-C-in + ABM-A-in β = 1/2) can achieve an accuracy of 49.02% using ResNet-34. Equipped with ResNet-50, our models can achieve 47.45% without snippet sampling or shifting inference (to show a fairer comparison), and 49.83% with these techniques, outperforming all methods under similar settings. On v2 set, our model can outperform all three models on validation (61.25%) and testing sets (60.13%). It even outperforms TSM which utilized 5crop protocol while we are feeding 224 × 224 single scaled frames to the model.

Two-Stream Models.
We train an ABM-A-in β=1/2 model using flow modality. This model achieves accuracy of 37.82% on v1 and 53.85% on v2 validation sets. We add its predictions to ABM-C-in and ABM-AC-in En by weight of 1:1 (second half in Table 4). The two-stream models achieve 50.09% and 51.77% accuracy on v1 validation set, outperforming all other methods. Our model is a bit worse than TSM on both test sets. We believe the Kineticspretraining provides more generality, and their 5-crop protocol and deeper backbone are also very beneficial for better performance. As our models outperform most state-of-theart methods under weaker settings, we conclude the ABMs are powerful modules for temporal modeling.

Efficiency Analysis
We compare models' FLOPs and inference speed (by video per second) in Table 5 together with I3D [49], ECO [55], and TSM [27]. VPS of TSM is obtained by reimplementation using the official code. The measurement is conducted on a same single GeForce GTX TITAN X with batch size set to be 8 (2 for I3D because of memory limitation). As we see our heaviest model ABM-A-in β=1 (is also ABM-C-in) has 1/3 of FLOPs and 5 times faster than I3D while achieving higher accuracy. Compared with efficiency-oriented ECO, two of our models have smaller FLOPs, but can achieve higher accuracy and perceive more frames. Compared with TSM, four of our models inference faster, and three perform better.
By comparing different ABM variants, we can clearly see the accuracy-speed tradeoff controlled by β: smaller β results in lighter model and worse performance. However, the performance drop is not very huge, indicating representing frame features with separated static and dynamic parts is effective. As ABM-C-top works significantly faster than in models, it is an ideal model for online video understanding.

Results on Other Datasets
We validate ABM-C-in module equipped with I3D backbone on Kinetics, UCF101, and HMDB51 datasets using RGB inputs. Because of our limited GPU resources, we only train our model on Kinetics for 8 epochs, with initial learning rate of 0.001 and decay by 0.1 at epoch 4. Thanks to the good initialization method of in models which benefits a lot from the pretrained backbone, it turns out the model works not bad on these datasets. In Table 6

Keyframe Selection Visualization
We conduct a keyframe selection experiment to qualitatively show that our ABM-C-top model can more effectively capture fine-grained temporal moments than TRN [54]. We compare these two models because they are both post-CNN temporal models and have similar structures. Specifically, on Something-v1 validation set we divide a video into 8 segments and randomly sample one frame per segment to generate a candidate tuple. 200 generated candidate tuples are fed to networks to get predictions, then we select the tuple with the highest top-1 prediction score as the Prediction: Wiping something off of something keyframes for this video. In Fig. 4 we show two videos in which two models selected different keyframes (only center 4 frames are shown since the rest selected frames are almost the same for both models). We can see our model performs better on capturing instant key moments in both videos: TRN focused on the falling moment of the objects, while our model captured the instant standing moment of edge supporting. A failure sample of our model is provided in Fig. 5. However the failure is caused by the wiping motion of a hand instead of capturing key moments, and the failure frequency is much lower.

Conclusion
We brought bilinear modules to temporal modeling, motivated by the temporal reasoning and fine-grained classification. The key points that made ABMs effective and efficient are 1. connection between MLPs and ABMs, and 2. static-plus-dynamic representation of frame features. By exploiting these two ideas, effective ABM temporal variants were proposed, which can work smoothly with existing deep CNNs. We showed in detail how subnets in deep CNNs can be converted to ABMs by adding the auxiliarybranch, while keeping the pretrained parameters valid. Our modules were instantiated with 2D-ResNet-34 and I3D backbones. Additionally, we introduced snippet sampling and shifting inference to boost performance of sparse-frame models. It was shown that top models are highly efficient while in models are highly effective. Our models outperformed most state-of-the-art methods on Something-v1 and v2, and were also competitive for traditional action recognition tasks. Though not explored in this paper, our modules should work with other techniques like attention mechanism [7,26] and non-local module [48], which are remained for future works.