SlowGuess/NAACL_2022_OCR huggingface dataset:
Jianhai Zhang $^{1}$ , Mieradilijiang Maimaiti $^{1}$ , Gao Xing $^{1}$ , Yuanhang Zheng $^{2,3,4}$ , and Ji Zhang $^{1,*}$ $^{1}$ Alibaba DAMO Academy
$^{2}$ Department of Computer Science and Technology, Tsinghua University, Beijing, China
$^{3}$ Institute for Artificial Intelligence, Tsinghua University, Beijing, China
<sup>4</sup>Beijing National Research Center for Information Science and Technology
{tanfan.zjh, mieradilijiang.mea, gaoxing.gx, zj122146}@alibaba-inc.com
zheng-yh19@mails.tsinghua.edu.cn
Text classification struggles to generalize to unseen classes with very few labeled text instances per class. In such a few-shot learning (FSL) setting, metric-based meta-learning approaches have shown promising results. Previous studies mainly aim to derive a prototype representation for each class. However, they neglect that it is challenging-yet-unnecessary to construct a compact representation which expresses the entire meaning for each class. They also ignore the importance to capture the inter-dependency between query and the support set for few-shot text classification. To deal with these issues, we propose a meta-learning based method MGIMN which performs instance-wise comparison followed by aggregation to generate class-wise matching vectors instead of prototype learning. The key of instance-wise comparison is the interactive matching within the class-specific context and episode-specific context. Extensive experiments demonstrate that the proposed method significantly outperforms the existing SOTA approaches, under both the standard FSL and generalized FSL settings.
Few-shot text classification has attracted considerable attention because of significant academic research value and practical application value (Gao et al., 2019; Yin, 2020; Brown et al., 2020; Bragg et al., 2021; Liu et al., 2021). Many efforts are devoted towards different goals like generalization to new classes (Gao et al., 2019; Ye and Ling, 2019; Nguyen et al., 2020; Bragg et al., 2021), adaptation to new domains and tasks (Bansal et al., 2020; Brown et al., 2020; Schick and Schütze, 2020; Gao et al., 2020; Bragg et al., 2021). Low-cost generalization to new classes is critical to deal with the growing long-tailed categories, which is common for intention classification (Geng et al., 2019;
Figure 1: The example of multi-grained few-shot text classification. The  $S_{nk}, S_{n}$  and  $S$  represent the instance level, class level and episode level interaction respectively. While "A" in the purple circle denotes alignment between query and instances. The "M" stands for matching operation.
Krone et al., 2020) and relation classification (Han et al., 2018; Gao et al., 2019).
To prevent over-fitting to few-shot new classes and avoid retraining the model when the class space changes, metric-based meta learning has become the major framework with significant results (Yin, 2020; Bansal et al., 2020). The core idea is that episode sampling is employed in meta-training phase to learn the relationship between query and candidate classes (Bragg et al., 2021). A key challenge is inducing class-wise representations from support sets because nature language expressions are diverse (Gao et al., 2019) and highly informative lexical features are unshared across episodes (Bao et al., 2019).
Under metric-based meta learning framework, many valuable backbone networks have emerged. Snell et al. (2017) presented prototypical network that computes prototype of each class using a simple mean pooling method. Gao et al. (2019) proposed hybrid attention mechanism to ease the negative effects of noisy support examples. Geng et al. (2019) proposed an induction network to
* Corresponding author: Ji Zhang
Human Language Technologies, pages 1937 - 1946
induce better prototype representations. Ye and Ling (2019) obtained each prototype vector by aggregating local matching and instance matching information. Bao et al. (2019) proposed a novel method to compute prototypes based on both lexical features and word occurrence patterns. All these previous works first obtain class-wise representations and then perform class-wise comparisons. However, it is challenging-yet-unnecessary to construct a compact representation which expresses the entire meaning for each class (Parikh et al., 2016). In text matching research, compare-aggregate methods which perform token-level comparisons followed by sentence-level aggregation has already been successful (Parikh et al., 2016; Tay et al., 2017; Yang et al., 2019). Besides backbone networks, there are still some work that can be further combined. Luo et al. (2021) utilized class-label information for extracting more discriminative prototype representation. Bansal et al. (2020) generated a large-scale meta tasks from unlabeled text in a self-supervised manner.
In this paper we propose Multi-grained Interactive Matching Network, a backbone network for few-shot text classification. The core difference between us with previous efforts is that our work performs instance-level comparisons followed by class-wise aggregation. Specifically, first, all text sequences including query and all support instances are encoded to contextual representations. Second, as depicted in Figure 1, we design a novel multi-grained interactive matching mechanism to perform instance-wise comparisons which capture the inter-dependency between query and all support instances. Third, class-wise aggregate layer obtains class-wise matching vector between query and each class. Finally, a prediction layer predicts final results. In contrast to standard FSL setting, generalized FSL setting is a more challenging-yet-realistic setting where seen classes and new classes are coexistent (Nguyen et al., 2020; Li et al., 2020a). In such a setting, we analyze the relationship between inference speed and the number of classes, and verify the necessity of retrieval, which is ignored by previous studies.
Our contributions are listed as follows:
- We propose MGIMN which is more concerned with matching features than semantic features through multi-grained interactive matching.
We verify the necessity of retrieval for realis
tic applications of few-shot text classification when the number of classes grows.
- We conduct extensive experiments and achieve SOTA results under both the standard FSL and generalized FSL settings.
Few-shot learning focuses on construct a classifier  $G(S, q) \to y$  which maps the query  $q$  to the label  $y$  given the support set  $S$ . Few-shot learning is significantly different from traditional machine learning. In traditional machine learning tasks, we directly sample batches of training data during training. Unlike traditional machine learning models, few-shot learning models usually adopt episode training strategy which means we build meta tasks using sampled training data in each training step.
Specifically, during each training step,  $N$  different classes are randomly chosen. After the classes are chosen, we sample  $R$  samples as query set  $Q$  and  $K$  samples for each class as support set  $S$  where  $Q \cap S \in \emptyset$ . For training, given the support set  $S = \{S_{n}^{k}; i = 1,.., N, j = 1,.., K\}$ , and query set  $Q = \{(q_{i}, y_{i}); i = 1,2,.., R, y_{i} \in 1,.., N\}$  which has  $R$  samples in each training step, the training objective is to minimize:
$$
J = - \frac {1}{R} \sum_ {(q, y) \in Q} \log (P (y | (S, q))). \tag {1}
$$
For evaluation, as we described in introduction section, there are two settings. In standard FSL setting, we do N-way K-shot sampling on the classes for validation and test (which are unseen during training) to construct episodes for validation and test. In generalized FSL setting, we reformulate the FSL task as  $C$ -way  $K$ -shot classification where  $C$  is the count of all classes for training, validation and test, and usually is far greater than  $N$ . In this setting, we construct episodes by sampling on all classes for test.
2.2 Matching Network
Matching Network (Vinyals et al., 2016) is a typical few-shot learning approach, which leverages the cosine similarity to perform few-shot classification. Specifically, for the query instance  $q$  and each support instance  $S_{n}^{k} \in S$ , the cosine similarity
Figure 2: The main architecture of multi-grained few-shot text classification model. The details of "Instance Matching Layer" totally same as depicted as Figure 1.
between  $q$  and  $S_{n}^{k}$  is computed as follow:
$$
\operatorname {s i m} \left(q, S _ {n} ^ {k}\right) = \frac {q \cdot S _ {n} ^ {k}}{\left| \left| q \right| \right| \left| \left| S _ {n} ^ {k} \right| \right|}. \tag {2}
$$
Then, we compute the probability distribution of the label  $y$  of the query  $q$  using attention:
$$
P (y \mid S, q) = \frac {\sum_ {k = 1} ^ {K} \exp \left(\operatorname {s i m} \left(q , S _ {y} ^ {k}\right)\right)}{\sum_ {n = 1} ^ {N} \sum_ {k = 1} ^ {K} \exp \left(\operatorname {s i m} \left(q , S _ {n} ^ {k}\right)\right)}. \tag {3}
$$
Finally, for any query instance  $q$ , we regard the class with the maximum probability as its label  $y$ :
$$
y = \underset {n} {\arg \max } P (y = n | S, q). \tag {4}
$$
2.3 Text Classification
As a basic task in NLP, text classification has attracted much attention. In previous works, different model architectures, including RNN (Zhou et al., 2016) and CNN (Kim, 2014) are used for text classification. After the appearance of pretrained language models like BERT (Devlin et al., 2019), they have become the mainstream method for text classification. In such methods, the input sentence is encoded into its representation using the Transformer (Vaswani et al., 2017) architecture through adding [CLS] token before the original input sentence  $\mathbf{x}$  and then computing the output
representation of  $[CLS]$  using the model.
$$
\mathbf {h} _ {\mathrm {C L S}} = \text {T r a n s f o r m e r} ([ \mathrm {C L S} ], \mathbf {x}; \theta), \tag {5}
$$
where  $\theta$  represents the model's parameters.
Then, according to the representation, the probability distribution of  $y$  can be computed as follow:
$$
P (y | \mathbf {x}; \theta) = \operatorname {s o f t m a x} \left(\mathbf {W} _ {\text {s o f t m a x}} \mathbf {h} _ {\mathrm {C L S}}\right), \tag {6}
$$
where  $\mathbf{W}_{\mathrm{softmax}}$  is the parameters of the softmax layer.
As illustrated in the Figure 2, MGIMN consists of four modules: Encoder Layer, Instance Matching Layer, Class-wise Aggregation Layer and Prediction Layer.
3.1 Encoder Layer
We employ transformer encoder from pre-trained BERT as encoder layer. Similar to the original work, we add a special token [CLS] before original text. Then the encoder layer takes a token sequence as input and outputs token-wise sequence representation. Instead of using the vector of [CLS] token as sentence-wise representation, we adopt final hidden states of the rest tokens for further fine-grained instance-wise matching.
We denote  $x = \{w_{1}, w_{2}, \dots, w_{l}\}$  as a token sequence. Encoder Layer outputs the token-wise representation  $h = \{h_{1}, h_{2}, \dots, h_{l}\}$ , where  $l$  denotes length of the token sequence. Query and each support instance are encoded individually. We denote  $q$  as encoded result of query and  $s_{nk}$  as encoded result of the  $k_{th}$  support instance of  $n_{th}$  class.
3.2 Instance Matching Layer
This is the core of our model. Instance-wise matching vectors are obtained by comparing query with each support instance.
3.2.1 Bidirectional Alignment
Following previous works (Parikh et al., 2016; Yang et al., 2019) in text matching, we use bidirectional alignment to capture inter-dependency between two text sequences.
$$
\widehat {a}, \widehat {b} = B i A l i g n (a, b) \tag {7}
$$
where a and b denote the token-wise sequence representations and  $BiAlign$  denotes the bidirectional alignment function defined as follows:
$$
e _ {i j} = \mathbf {F} \left(a _ {i}\right) ^ {\mathrm {T}} \mathbf {F} \left(b _ {j}\right) \tag {8}
$$
$$
\widehat {a} _ {i} = \sum_ {j = 1} ^ {l _ {b}} \frac {\exp \left(e _ {i j}\right)}{\sum_ {k = 1} ^ {l _ {b}} \exp \left(e _ {i k}\right)} b _ {j} \tag {9}
$$
$$
\widehat {b _ {j}} = \sum_ {i = 1} ^ {l _ {a}} \frac {\exp \left(e _ {i j}\right)}{\sum_ {k = 1} ^ {l _ {a}} \exp \left(e _ {k j}\right)} a _ {i} \tag {10}
$$
where  $a_{i}$  and  $b_{j}$  denotes representation of  $i_{th}$  and  $j_{th}$  token of  $a$  and  $b$ , respectively,  $\widehat{a_i}$  and  $\widehat{b_j}$  denote the aligned representations, and  $F$  is a single-layer feed forward network.
3.2.2 Multi-grained Interactive Matching
In few-shot text classification, judging whether query and each support instance belong to the same category cannot be separated from class-specific context and episode-specific context. There are three components including alignment, fusion and comparison.
For alignment, besides local alignment between query and each support instance, we also consider their alignments with global context information. We denote  $S_{n} = \text{concat}(\{s_{nj}\}_{j=1}^{K})$  as class-specific context and  $S = \text{concat}(\{S_{i}\}_{i=1}^{N})$  as
episode-specific context. The multi-grained alignments for query and each support instance are performed as follows:
$$
q _ {n k} ^ {\prime}, s _ {n k} ^ {\prime} = B i A l i g n (q, s _ {n k})
$$
$$
q _ {n, -} ^ {\prime \prime} = B i A l i g n (q, S _ {n})
$$
$$
s _ {n k, -} ^ {\prime \prime} = B i A l i g n \left(s _ {n k}, S _ {n}\right) \tag {11}
$$
$$
q ^ {\prime \prime \prime}, _ {-} = B i A l i g n (q, S)
$$
$$
s _ {n k, -} ^ {\prime \prime \prime} = B i A l i g n (s _ {n k}, S)
$$
where  $q_{nk}^{\prime}, q_{n}^{\prime \prime}$  and  $q^{\prime \prime \prime}$  denote instance-aware, class-aware and episode-aware query representations respectively,  $s_{nk}^{\prime}, s_{nk}^{\prime \prime}$  and  $s_{nk}^{\prime \prime \prime}$  denote query-aware, class-aware and episode-aware support instance representations respectively.
For fusion, we fuse original representation and three kinds of aligned representations together as follows:
$$
\boldsymbol {q} _ {\boldsymbol {n} \boldsymbol {k}} ^ {\prime} = H _ {1} \left(q; q _ {n k} ^ {\prime}; \left| q - q _ {n k} ^ {\prime} \right|; q \odot q _ {n k} ^ {\prime}\right)
$$
$$
\boldsymbol {q} _ {\boldsymbol {n k}} ^ {\prime \prime} = H _ {2} (q; q _ {n} ^ {\prime \prime}; \left| q - q _ {n} ^ {\prime \prime} \right|; q \odot q _ {n} ^ {\prime \prime})
$$
$$
\boldsymbol {q} _ {\boldsymbol {n k}} ^ {\prime \prime \prime} = H _ {3} (q; q ^ {\prime \prime \prime}; \left| q - q ^ {\prime \prime \prime} \right|; q \odot q ^ {\prime \prime \prime})
$$
$$
\pmb {s} _ {\pmb {n k}} ^ {\prime} = H _ {1} (s _ {n k}; s _ {n k} ^ {\prime}; \left| s _ {n k} - s _ {n k} ^ {\prime} \right|; s _ {n k} \odot s _ {n k} ^ {\prime})
$$
$$
\boldsymbol {s} _ {\boldsymbol {n k}} ^ {\prime \prime} = H _ {2} \big (s _ {n k}; s _ {n k} ^ {\prime \prime}; \left| s _ {n k} - s _ {n k} ^ {\prime \prime} \right|; s _ {n k} \odot s _ {n k} ^ {\prime \prime} \big)
$$
$$
\boldsymbol {s} _ {\boldsymbol {n k}} ^ {\prime \prime \prime} = H _ {3} \left(s _ {n k}; s _ {n k} ^ {\prime \prime \prime}; \left| s _ {n k} - s _ {n k} ^ {\prime \prime \prime} \right|; s _ {n k} \odot s _ {n k} ^ {\prime \prime \prime}\right)
$$
$$
\boldsymbol {q} _ {\boldsymbol {n k}} = H \left(\boldsymbol {q} _ {\boldsymbol {n k}} ^ {\prime}; \boldsymbol {q} _ {\boldsymbol {n k}} ^ {\prime \prime}; \boldsymbol {q} _ {\boldsymbol {n k}} ^ {\prime \prime \prime}\right) \tag {13}
$$
$$
s _ {n k} = H \left(s _ {n k} ^ {\prime}; s _ {n k} ^ {\prime \prime}; s _ {n k} ^ {\prime \prime \prime}\right)
$$
where  $H_{1}, H_{2}, H_{3}, H$  are feed forward networks with single-layer and initialize with independent parameters,  $\odot$  denotes the element-wise multiplication operation, and ; denotes concatenation operation.
For comparison, the instance-wise matching vector is computed as follows:
$$
q _ {\vec {n k}} ^ {\rightarrow} = \left[ \max  \left(\left\{\boldsymbol {q} _ {\boldsymbol {n k}} \right\}\right); a v g \left(\left\{\boldsymbol {q} _ {\boldsymbol {n k}} \right\}\right)\right]
$$
$$
\vec {s _ {n k}} = \left[ \max  \left(\left\{\boldsymbol {s} _ {\boldsymbol {n k}} \right\}\right); a v g \left(\left\{\boldsymbol {s} _ {\boldsymbol {n k}} \right\}\right) \right]
$$
$$
m _ {n k} ^ {\rightarrow} = G \left(q _ {n k} ^ {\rightarrow}; s _ {n k} ^ {\rightarrow}; \left| q _ {n k} ^ {\rightarrow} - s _ {n k} ^ {\rightarrow} \right|; q _ {n k} ^ {\rightarrow} \odot s _ {n k} ^ {\rightarrow}\right) \tag {14}
$$
where  $q_{nk}$  is a  $l_q\times D$  matrix,  $\pmb{s}_{nk}$  is a  $l_s\times D$  matrix,  $\vec{q_{nk}}$  and  $s_{nk}^{\rightarrow}$  are vectors with shape  $(1\times 2D)$ ,  $G$  is single-layer feed forward networks,  $l_{q}$  and  $l_{s}$  are sequence length of query and support instance respectively, and  $D$  is hidden size.
3.3 Class Aggregation Layer
This layer aggregate instance-wise matching vectors into class-wise matching vectors for final prediction.
$$
\vec {c _ {n}} = [ m a x (\{m _ {n k} ^ {\rightarrow} \} _ {k = 1} ^ {K}); a v g (\{m _ {n k} ^ {\rightarrow} \} _ {k = 1} ^ {K}) ] (1 5)
$$
where  $c_{n}^{\rightarrow}$  denotes the final matching vector of  $n_{th}$  class, “;” denotes the concatenation of two vectors and  $m_{nk}^{\rightarrow}$  denotes instance-wise matching vector produced by instance matching layer.
Finally, prediction layer, which is a two-layer fully connected network with the output size is 1, is applied to the matching vector  $\vec{c_n}$  and outputs final predicted result.
$$
l o g i t _ {n} = M L P (\vec {c _ {n}}), n = 1,.., N \tag {16}
$$
4.1.1 The preparation of dataset
The proposed method has been evaluated on five diverse corpora: OOS (Larson et al., 2019), Liu (Liu et al., 2019), FaqIr (Karan and Snajder, 2016), Amzn (Yury., 2020) and Huffpost (Misra., 2018). Among them, OOS, Liu and FaqIr datasets are all intent classification datasets. Amzn dataset is designed for fine-grained classification of product reviews. Huffpost dataset is constructed to identify the types of news based on headlines and short descriptions. The dataset characteristics is listed in Table 1. For the standard FSL setting, we construct the "support & query" set by sampling the unique N classes and K samples each class, and R samples for each of classes, respectively. We conduct two groups of experiments using  $N = [5, 10]$ ,  $K = 5$  and  $R = 5$ . In the evaluation phase, we sample 500 episodes and report the average accuracy. In generalized FSL setting(GFSL for short), we train the model with episode sampling of 5-way 5-shot. And then we evaluate the model performance with C-way K-shot.
For all experiments, we divide all datasets for 5 times using different random seeds, just like the way of cross validation, to remove the impact of dataset division. And we conduct 3 experiments for each model by using different random seeds for model initialization. The final results are reported by averaging  $5 \times 3 = 15$  runs.
For fair comparison, all models implemented in this paper adopt BERT-Tiny $^{1}$  as encoder layer which is a 2-layer 128-hidden 2-heads version of BERT. Meanwhile, these models initialized their paramaeters using the PTM published by Google and fine-tuned during training procedure. Besides, the encoder layer and all parameters of other layers are randomly initialized. We fix some hyperparameters with default values such as the hidden size 128, we also exploit Adam optimizer in all experiment settings. The learning rate is tuned from  $1e^{-5}$  to  $1e^{-4}$  on validation dataset. Dropout with a rate of 0.1 is applied before each fully-connected layer. The feed-forward networks described in section 3 (e.g.  $F, H_{1}, H_{2}, H_{3}, H$  and  $G$ ) are all single fully-connected layers. The prediction layer is a two-layer fully-connected layer.
It is vital to compare the introduced method with some strong baselines with two evaluation metrics mentioned above. Note that we re-implement all methods with the same pre-trained encoder for fairly comparison.
- Prototypical Network (Proto)(Snell et al., 2017) is the first designed and applied to image classification and has also been used to deal with the text classification issue in recent studies.
- Matching Network (Matching)(Vinyals et al., 2016) computes the similarity both on each query and per support samples, and then averages them as final prediction score.
- Induction network (Induction)(Geng et al., 2019) proposes an induction module to induce the prototype by using dynamic routing.
- Proto-HATT(Gao et al., 2019) is introduced to deal with the issue of noisy and diverse by leveraging instance-level attention and feature-level attention.
- MLMAN(Ye and Ling, 2019), can be regarded as one of the variants of Proto, encodes query and support in an interactive way.
Overall Performance Our key experiment results are given in Table 2, 3 and 4. We report
$^{1}$  https://github.com/google-research/bert
Datasets	Standard FSL Setting	Generalized FSL Setting
#sentences	\(C_{tr}/C_{val}/C_{test}\)	C	K	#sc	#uc	\(\#D_{tr}\)	\(\#D_{val}\)	\(\#D_{test}\)
OOS	22500	50/50/50	150	5	50	100	7000	1250	1250
Liu	25478	18/18/18	54	5	18	36	8312	450	450
Amzn	3057	106/106/106	318	5	106	212	1043	530	530
Huffpost	41000	14/13/14	41	5	14	27	13860	340	340
FaqIr	1233	17/16/17	50	5	17	33	309	381	381
Table 1: The detailed dataset statistics. In standard FSL setting, we cut all classes into trainset/validset/testset according to the ratio with 1:1:1. In generalized FSL setting, we reformulate task as a C-way K-shot classification in which only subset of classes are seen in training phase.
Methods	OOS	Liu	FaqIr
5-way	10-way	GFSL	5-way	10-way	GFSL	5-way	10-way	GFSL
Proto	92.20	87.91	61.94	82.46	73.23	47.66	89.83	81.56	60.78
Matching	89.78	84.41	58.34	78.25	67.45	41.95	86.74	78.77	53.85
Induction	80.44	70.92	34.00	65.58	51.56	24.73	71.62	56.99	20.10
Proto-HATT	92.84	89.11	65.52	82.38	75.29	51.27	85.01	76.17	62.62
MLMAN	95.99	93.41	74.39	87.39	79.82	57.24	94.77	89.49	74.42
MGIMN(ours)	96.36	94.00	76.23	87.84	80.60	57.66	95.14	90.69	75.81
Table 2: Experiment results of standard FSL (n-way 5-shot) and generalized FSL with intent classification datasets (OOS,Liu and FaqIr datasets), while the  $n$  is set 5 and 10 respectively.
Methods	Amzn
5-way	10-way	GFSL
Proto	78.40	69.02	41.03
Matching	75.73	64.17	38.34
Induction	64.02	50.12	20.09
Proto-HATT	78.05	69.00	41.81
MLMAN	85.64	79.39	46.71
MGIMN(ours)	85.96	80.07	49.46
Table 3: Experiment results of standard FSL and generalized FSL settings on Amzn datasets, while the FSL setting is same with Table 2.
the averaged scores over 15 runs (different seen-unseen class splits and random seeds as introduced in section 4.1.1) for each dataset and model. Our method remarkably better than all baselines on the five diverse corpora, especially in more challenging generalized FSL setting: the improvements on Huffpost and Amzn datasets are  $2.83\%$  and  $2.75\%$  respectively.
Generalized FSL In most studies of text classification (Bao et al., 2019; Gao et al., 2019) with few-shot manner, N-way K-shot accuracy is the standard evaluation metric. There are two problems: (1) The metric is not challenging, usually  $N = 5$  or  $N = 10$ , much smaller than  $C$ . We
also can see that high scores are often reported in some work(Bao et al., 2019; Gao et al., 2019). (2) It is unable to reflect the real application scenarios where we usually face the entire class space (both seen classes and unseen classes). Consequently, the more challenging generalized FSL evaluation metric is employed to focus on the problems. As shown in Table 2, 3 and 4, the performance of generalized FSL evaluation is worse and more challenging than standard FSL. It is very meaningful in realistic scenario and can contribute to the further research. It is noteworthy that, comparing with Proto, our proposed approach makes bigger improvement in the challenging generalized FSL metric (GFSL) than the improvements in standard FSL metric(FSL), e.g. OOS dataset:  $14.29\%$  of GFSL vs  $6.09\%$  of FSL and FAQIr dataset:  $15.03\%$  of GFSL vs  $9.13\%$  of FSL. Obviously, it can be implied from the experiment results that, the presented approach has higher effectiveness among such challenging scenarios.