**M2Det** is a one-stage object detection model that utilises a Multi-Level Feature Pyramid Network ([MLFPN](https://paperswithcode.com/method/mlfpn)) to extract features from the input image, and then similar to [SSD](https://paperswithcode.com/method/ssd), produces dense bounding boxes and category scores based on the learned features, followed by the non-maximum suppression (NMS) operation to produce the final results.

GCT first collects global information by computing the l2-norm of each channel. Next, a learnable vector $ \alpha $ is applied to scale the feature. Then a competition mechanism is adopted by channel normalization to interact between channels.

Unlike previous methods, GCT first collects global information by computing the $l_{2}$-norm of each channel. 
Next, a learnable vector $\alpha$ is applied to scale the feature.
Then a competition mechanism is adopted by 
channel normalization to interact between channels. 
Like other common normalization methods, 
a learnable scale parameter $\gamma$ and bias $\beta$ are applied to 
rescale the normalization.
However, unlike previous methods,
GCT adopts tanh activation to control the attention vector.
Finally, it not only multiplies the input by the attention vector but also adds an identity connection. GCT can be written as: 
\begin{align}
    s = F_\text{gct}(X, \theta) & = \tanh (\gamma CN(\alpha \text{Norm}(X)) + \beta)
\end{align}
\begin{align}
    Y & = s  X + X
\end{align}

where $\alpha$, $\beta$ and $\gamma$ are trainable parameters. $\text{Norm}(\cdot)$ indicates the $L2$-norm of each channel. $CN$ is  channel normalization.

A GCT block has fewer parameters than an SE block, and as it is  lightweight, 
 can be added after each convolutional layer of a CNN.

Gated Channel Transformation for Visual Recognition

M2Det

M2Det: A Single-Shot Object Detector based on Multi-Level Feature Pyramid Network

A **QRNN**, or **Quasi-Recurrent Neural Network**, is a type of recurrent neural network that alternates convolutional layers, which apply in parallel across timesteps, and a minimalist recurrent pooling function that applies in parallel across channels. Due to their increased parallelism, they can be up to 16 times faster at train and test time than [LSTMs](https://paperswithcode.com/method/lstm).

Given an input sequence $\mathbf{X} \in \mathbb{R}^{T\times{n}}$ of $T$ n-dimensional vectors $\mathbf{x}\_{1}, \dots, \mathbf{x}\_{T}$, the convolutional subcomponent of a QRNN performs convolutions in the timestep dimension with a bank of $m$ filters, producing a sequence $\mathbf{Z} \in \mathbb{R}^{T\times{m}}$ of m-dimensional candidate vectors $\mathbf{z}\_{t}$. Masked convolutions are used so filters can not access information from future timesteps (implementing with left padding).

Additional convolutions are applied with separate filter banks to obtain sequences of vectors for the
elementwise gates that are needed for the pooling function. While the candidate vectors are passed
through a $\tanh$ nonlinearity, the gates use an elementwise sigmoid. If the pooling function requires a
forget gate $f\_{t}$ and an output gate $o\_{t}$ at each timestep, the full set of computations in the convolutional component is then:

$$ \mathbf{Z} = \tanh\left(\mathbf{W}\_{z} ∗ \mathbf{X}\right) $$
$$ \mathbf{F} = \sigma\left(\mathbf{W}\_{f} ∗ \mathbf{X}\right) $$
$$ \mathbf{O} = \sigma\left(\mathbf{W}\_{o} ∗ \mathbf{X}\right) $$

where $\mathbf{W}\_{z}$, $\mathbf{W}\_{f}$, and $\mathbf{W}\_{o}$, each in $\mathbb{R}^{k×n×m}$, are the convolutional filter banks and ∗ denotes a [masked convolution](https://paperswithcode.com/method/masked-convolution) along the timestep dimension.  Dynamic [average pooling](https://paperswithcode.com/method/average-pooling) by Balduzzi & Ghifary (2016) is used, which uses only a forget gate:

$$ \mathbf{h}\_{t} = \mathbf{f}\_{t} \odot{\mathbf{h}\_{t−1}} + \left(1 − \mathbf{f}\_{t}\right) \odot{\mathbf{z}\_{t}} $$ 

Which is denoted f-pooling. The function may also include an output gate:

$$ \mathbf{c}\_{t} = \mathbf{f}\_{t} \odot{\mathbf{c}\_{t−1}} + \left(1 − \mathbf{f}\_{t}\right) \odot{\mathbf{z}\_{t}} $$ 

$$ \mathbf{h}\_{t} = \mathbf{o}\_{t} \odot{\mathbf{c}\_{t}} $$

Which is denoted fo-pooling. Or the recurrence relation may include an independent input and forget gate:

$$ \mathbf{c}\_{t} = \mathbf{f}\_{t} \odot{\mathbf{c}\_{t−1}} + \mathbf{i}\_{t}\odot{\mathbf{z}\_{t}} $$ 

$$ \mathbf{h}\_{t} = \mathbf{o}\_{t} \odot{\mathbf{c}\_{t}} $$

Which is denoted ifo-pooling. In each case $h$ or $c$ is initialized to zero. The recurrent part sof these functions must be calculated for each timestep in the sequence, but parallelism along feature dimensions means evaluating them even over long sequences requires a negligible amount of computation time.

A single QRNN layer thus performs an input-dependent pooling, followed by a gated linear combination of convolutional features. As with convolutional neural networks, two or more QRNN layers should be stacked to create a model with the capacity to approximate more complex functions.

Source	M2Det: A Single-Shot Object Detector based on Multi-Level Feature Pyramid Network
Year	2000
Data Source	CC BY-SA - https://paperswithcode.com