EGTJ: An Unsupervised and Non-Parametric Approach for Efficient Text Classification Under Resource-Limited Environments

Abstract

Deep neural networks (DNNs) dominate text classification but suffer from high computational costs and poor generalization in data-scarce or Out-of-Distribution (OOD) environments. Conversely, non-parametric methods like compression-based offer robustness but incur prohibitive inference latency due to the reliance on exhaustive pairwise comparisons. To bridge this gap, this study proposes EGTJ, a training-free framework that introduces a novel retrieval-augmented compression architecture. Unlike prior works that apply similarity metrics in isolation, EGTJ utilizes an inverted-index pre-filtering mechanism to dynamically constrain the comparison scope, effectively reducing algorithmic complexity from linear to constant time relative to the training set size. Furthermore, a tri-metric fusion strategy is introduced that integrates information-theoretic (gzip), lexical (TF-IDF), and structural (Jaccard) similarities to mitigate the inherent biases of individual metrics. Experimental results across five in-distribution and four OOD datasets demonstrate that EGTJ achieves superior accuracy over all baseline methods—notably outperforming BERT by over 30% in 5-shot OOD scenarios—while simultaneously slashing inference latency by orders of magnitude compared to standard compression-based approaches. These findings present EGTJ as a scalable, high-performance alternative for resource-constrained NLP, effectively solving the scalability bottleneck of non-parametric classification.

1. Introduction

The rapid development of artificial intelligence has caused a major change in natural language processing (NLP), leading to systems with unprecedented semantic acuity. In this context, text classification is a fundamental skill that supports a wide range of functions, from figuring out what someone is feeling to sorting topics [1]. Deep Neural Networks (DNNs) have become the most common standard, thanks to their complex designs and huge collections of labeled data [2]. However, this level of performance comes at a high cost. The inherent computational exuberance and rigid dependence on supervision render these models increasingly untenable in resource-constrained environments or Out-of-Distribution (OOD) contexts [3], where the scarcity of annotated exemplars precludes their deployment.

There is no doubt that DNNs are great at finding high-dimensional dependencies, but using such a lot of parameters for text classification is often too much work for computers. Empirical investigations often validate more economical architectures; specifically, Adhikari et al. [4] demonstrated that a suitably regularized Long Short-Term Memory (LSTM) network achieves performance equivalence with considerably more complex models. Shen et al. [5] corroborate this observation, revealing that foundational word embeddings can, in certain contexts, surpass the effectiveness of Convolutional Neural Networks (CNNs) and Recurrent Neural Networks (RNNs), thereby contesting the dominant belief that architectural complexity is essential for accuracy.

Traditional unsupervised methods like term frequency-inverse document frequency (TF-IDF) and Jaccard similarity offer efficient text classification. For instance, TF-IDF has been applied to emotion analysis [6], Huang et al. [7] using Jaccard similarity to achieved 90.07% accuracy on Vietnamese text classification, and Jiang et al. [8] use gzip to offer a promising middle ground by exploiting information-theoretic similarity. These methods are competitive and require no training, but they suffer from two major drawbacks: (1) inefficiency due to exhaustive pairwise comparisons with all training samples [8], and (2) limited generalization capacity stemming from reliance on a single similarity metric—such as gzip, which overlooks lexical relevance and structural similarity [6,7].

However, a critical research gap remains in making non-parametric methods scalable. While recent compression-based approaches (such as gzip) have shown remarkable robustness to OOD data, they suffer from a severe computational bottleneck: they require exhaustive pairwise comparisons between the test instance and every single training sample ($O\left(n\right)$ complexity). This renders them practically unusable for large-scale datasets or real-time applications. Addressing this exigency, this study proposes EGTJ, an architecture that harmonizes the speed of Elasticsearch (ES) retrieval with the resilience of hybrid metric fusion. This integration decouples inference costs from dataset magnitude—reducing complexity to a constant $O\left(m\right)$—and thereby renders robust, training-free NLP viable within resource-constrained environments previously inaccessible to heavy neural architectures or iterative compression schemes. In summary, the main contributions of this study are as follows:

Scalable Architecture for Non-Parametric Classification: To resolve the prohibitively high computational overhead of recent compression-based methods [8], this work proposes a novel integration of ES-based pre-filtering with compression classification. This architecture decouples inference latency from dataset size by restricting the search space to a dynamically retrieved candidate subset. This design yields a 16-fold computational acceleration—collapsing total runtime from 13,518 s to a mere 847 s—thereby transforming a theoretically robust methodology into a tractable, real-time solution.

Robustness via Orthogonal Metric Fusion: A synergistic fusion strategy is proposed that triangulates three orthogonal similarity axes: global information-theoretic regularity (gzip), local lexical weighting (TF-IDF), and set-theoretic overlap (Jaccard). Empirical validation on the AGNews corpus demonstrates that this specific tripartite synthesis effectively mitigates localized noise, yielding a 2.9% accuracy improvement over unimodal baselines and stabilizing variance across heterogeneous data shifts.

Superior Generalization in Zero-Training Regimes: This work demonstrates that EGTJ effectively alleviates the “cold start” problem in text classification. By leveraging its parameter-free architecture to handle distributional shifts, the framework surpasses fine-tuned Transformer architectures (such as BERT) by over 30% in 5-shot OOD scenarios. This establishes EGTJ as a scalable, high-performance paradigm for lightweight deployments where computational parsimony and label scarcity are critical constraints.

2. Related Work

Text classification is a fundamental aspect of NLP that has been examined through various methodological perspectives, each addressing the trilemma of computational efficiency, accuracy, and domain adaptability. This section divides the research into three main categories: methods based on similarity, algorithms based on compression, and deep neural architectures.

2.1. Similarity-Based Text Classification

The effectiveness of similarity metrics, including metadata-augmented retrieval [9] of ES, lexical weighting of TF-IDF [10], and set-theoretic intersections of Jaccard [7], has been thoroughly documented. These methods rely on utilizing the underlying structural and lexical similarities within corpora to aid in categorization. Kim et al. [9] significantly redefined classification boundaries by utilizing metadata associated with query keywords and summaries, thereby enhancing the functionality of retrieval systems beyond basic search capabilities. Their method links the search results of extracted keywords to the metadata, which improves natural language search and the classification of academic papers through ES. However, this needs schema design and domain expertise. Qin et al. [10] created a new multi-level TF-IDF algorithm that takes into account the lengths of the document and category as well as the term frequency in both the document and the category. However, it did not provide a thorough explanation and analysis of the proposed method, which could make it harder to understand and copy. Huang et al. [7] attained 90.07% accuracy on Vietnamese texts utilizing Jaccard similarity, neglecting term significance.

While these methods are individually effective, they are often applied in isolation and face common limitations: ES alone relies heavily on lexical matching and may miss deeper semantic or information-theoretic similarities; TF-IDF is distribution-dependent and struggles with vocabulary shifts in OOD scenarios; Jaccard similarity does not account for term frequency or importance. Recent attempts to combine similarity measures remain limited. For instance, Arabi & Akbari [11] proposed a hybrid weighted similarity for plagiarism detection, but their method is task-specific and not designed for efficient large-scale classification.

2.2. Compression-Based Text Classification

Compression-Based Text Classification (CBTC) represents a substantial divergence from conventional feature engineering, its effectiveness stemming from the stringent convergence of information theory and algorithmic complexity. Bennett et al. [12] laid the theoretical foundation for this paradigm with the Normalized Information Distance (NID), which Cilibrasi and Vitányi [13] later turned into a practical tool for text analysis called the Normalized Compression Distance (NCD). Building on this idea, Montemurro [14] suggested that whole-text compression could decode latent linguistic entropy. Jiang et al. [8] proved this idea by showing that combining lossless gzip compression with kNN classifiers gives the same results as deep learning baselines. However, the usefulness of these kinds of methods is fundamentally limited by a scalability bottleneck: they require $O\left(n\right)$ complexity because they rely on exhaustive pairwise comparisons, which makes them too expensive to use on large corpora. EGTJ solves this particular problem by adding an Elasticsearch pre-filtering stage, which reduces the search space to a constant $O\left(m\right)$ ($m\ll n$). By further combining the compression signal with the lexical specificity of TF-IDF and the set-theoretic rigor of Jaccard similarity, the framework gets around the semantic blindness of pure compression. This results in a hybrid architecture that is much more accurate and much faster at making inferences than monolithic compression baselines (see Section 5.3.1 and Section 5.3.2).

2.3. Deep Learning for Text Classification

There are two main types of deep learning frameworks for text classification: transductive frameworks, like Graph Convolutional Networks (GCNs) [15], and inductive architectures, like RNNs and CNNs. This study only looks at inductive learning because transductive methods require access to the test set during training, which is not usually the case in real-world situations. Zhang et al. [16] confirmed the effectiveness of inductive methodologies by utilizing character-level CNNs with millions of parameters, showcasing strong feature extraction abilities. In the same way, Chung et al. [17] came up with the Gated Recurrent Unit (GRU) to cut down on parameter overhead without hurting performance in the RNN field. Zhou et al. [18] added attention mechanisms to LSTMs to make them better at modeling long-range dependencies. The Transformer architecture [19] and its bidirectional successor, BERT [20], changed the game by setting new performance standards through self-attention mechanisms and large-scale pre-training. In OOD situations, though, these models are still fragile. Systematic changes in vocabulary, topic, or domain can cause performance to drop significantly without careful fine-tuning [3,21].

Even though they are the most popular, deep learning methods have problems with too many parameters, a heavy reliance on labeled data, and bad zero-shot generalization [21]. EGTJ, on the other hand, is a training-free, non-parametric option that doesn’t need model parameters, and special hardware acceleration. EGTJ solves the problems of DNNs that make them less efficient and less generalizable, especially in low-resource and OOD settings, by combining scalable ES retrieval with a multi-metric fusion strategy. Similarity-based heuristics are fast but have some limitations, and compression-based methods are strong but require a lot of processing power. EGTJ combines the best of both approaches. It uses ES for constant-time retrieval and combines different similarity metrics (gzip, TF-IDF, Jaccard) to provide strong, scalable classification without the high resource requirements of deep learning.

3. Preliminaries

This section talks about the basic methods used in this study. These methods are the foundation of the EGTJ method. They help with text classification, feature representation, similarity calculation, and effective information retrieval.

3.1. Gzip

Gzip is a widely used lossless compression tool [8] that uses the LZ77 algorithm and Huffman coding together to make data encoding as efficient as possible. There are two basic ideas behind using compression in classification: (1) compression algorithms are good at estimating how regular the data is, and (2) instances within the same category are more consistent with each other and therefore easier to compress when combined than instances from different categories.

Consider three texts, $\{t1,t2,t3\}$, where $\{t1,t2\}$ have a categorical affinity that is different from $t3$. Let $C(·)$ be the length of the compressed byte. We assert that the marginal entropy necessary to encode $t2$ in the context of $t1$ is unequivocally less than that required for $t3$, expressed as $C\left(t1t2\right)-C\left(t1\right)<C\left(t1t3\right)-C\left(t1\right)$. The differential $C\left(t1t2\right)-C\left(t1\right)$ measures the information that $t2$ has that $t1$ doesn’t. For example, think about these samples:

• t1: ‘Applications to bioinformatics’
• t2: ‘Applications to mobile computing’
• t3: ‘Inpainting-based compression, perceptual coding’

The Compression-based Length Metric (CLM) quantifies this relationship, based on the information-theoretic framework developed by Chen, Li, and colleagues [22,23,24].

$$CLM(x,y)=1-{\displaystyle \frac{C\left(x\right)-C(x\mid y)}{C\left(xy\right)}},$$

(1)

where the term $C\left(x\right)-C\left(x\right|y)$ serves as an upper bound on the mutual algorithmic information between sequences [23], approximating Kolmogorov complexity. This study use the concatenation difference $C\left(xy\right)-C\left(y\right)$ to find the conditional complexity $C\left(x\right|y)$ in practice. This method takes advantage of the LZ77 algorithm’s shared dictionary mechanism to accurately measure how much less bit-rate is needed to encode x when the compressor has been set up to work with the context of y.

3.2. TF-IDF

TF-IDF is a common way to give weight to information retrieval and text mining [6]. TF-IDF shows how important each word is in a document. TF tells you how many times a word appears in a document, while IDF tells you how common a word is in all documents. The mathematical formalization is defined as follows.

Term Frequency (TF): For a specific term t residing within document d, the normalized frequency is calculated as:

$$\mathrm{TF}(t,d)={\displaystyle \frac{f_{t,d}}{{\sum }_{t^{\prime }\in d}{f}_{t^{\prime },d}}}$$

(2)

where $f_{t,d}$ denotes the raw occurrence count of term t in document d.

Inverse Document Frequency (IDF): To capture global rarity across the document collection D, the IDF metric is computed as:

$$\mathrm{IDF}(t,D)=log\left(1+{\displaystyle \frac{N}{n_t+1}}\right)$$

(3)

where:

• $N=\left|D\right|$ is the total number of documents
• $n_t=\left|\{d\in D:t\in d\}\right|$ is the document frequency of term t

TF-IDF Weight:

$$TFIDF(t,d,D)=TF(t,d)\times IDF(t,D).$$

(4)

3.3. Jaccard Similarity Coefficient

The Jaccard similarity coefficient [7] is a measure of similarity between two sets, defined as the size of the intersection divided by the size of the union of the sets. In the context of text classification, it can be used to measure the similarity between the set of words in two texts. The Jaccard similarity coefficient between two sets A and B is calculated as

$$J(A,B)={\displaystyle \frac{|A\cap B|}{|A\cup B|}},$$

(5)

where $|A\cap B|$ is the number of elements in both sets A and B, and $|A\cup B|$ is the number of elements in either set A or B, or in both.

3.4. ES Indexing and BM25 Ranking

ES is a distributed, RESTful search and analytics engine built on Apache Lucene [9]. It is designed for fast, scalable full-text search through an inverted index structure. In an inverted index, each unique term (token) is associated with a list of documents containing that term, along with positional and frequency information. This enables sub-linear retrieval time for keyword queries.

In EGTJ, this work use ES as a pre-filtering mechanism to drastically reduce the candidate search space before applying computationally expensive similarity metrics (gzip, TF-IDF, Jaccard). The indexing pipeline includes:

• Tokenization: The standard analyzer performs lowercasing, Unicode text segmentation, and stopword removal.
• Index mapping: Each document is stored as a JSON object with fields "text" (analyzed full text) and "label".
• Sharding and refresh: This work use 5 shards for parallel querying and a 1-s refresh interval for near-real-time availability.

For retrieval, ES employs the BM25 ranking function [25], a probabilistic adaptation of the TF-IDF paradigm. Given a query Q containing terms $q_1,\dots ,q_n$ and a document D, the BM25 score is computed as:

$$\mathrm{BM}25(D,Q)=\sum _{i=1}^n\mathrm{IDF}\left(q_i\right)·{\displaystyle \frac{f(q_i,D)·(k_1+1)}{f(q_i,D)+k_1·\left(1-b+b·\frac{\left|D\right|}{\mathrm{avgdl}}\right)}},$$

where:

• $f(q_i,D)$ is the term frequency of $q_i$ in D,
• $\left|D\right|$ is the document length in words,
• $\mathrm{avgdl}$ is the average document length in the collection,
• $k_1$ and b are tuning parameters (this work use $k_1=1.2$, $b=0.75$ as ES defaults).

BM 25 improves upon classical TF-IDF by saturating term frequencies and normalizing document length, making it more robust for short-text retrieval. In EGTJ, this work retrieve the top-m documents ranked by BM25 for each test instance, forming a candidate set S that is orders of magnitude smaller than the full training set.

3.5. Theoretical Motivation for Component Synergy

The architectural philosophy of EGTJ is based on combining three different types of similarity paradigms: information-theoretic, lexical, and set-theoretic. This is done to get around the problems that come with unimodal classification. This study examine this synergistic interaction using two separate theoretical frameworks.

Complementary Similarity Measures: Gzip uses the CLM to get a rough idea of Kolmogorov complexity, which lets it decode hidden semantic structures and topic consistency. However, its effectiveness is limited in short-text contexts due to the scarcity of compressible redundancy [8]. TF-IDF, on the other hand, uses lexical statistics to measure term specificity. It works well for in-distribution data, but it doesn’t know about structure and breaks down quickly when the vocabulary changes, which is common in OOD environments [6]. Jaccard similarity works as a set-theoretic stabilizer that is strong against permutation but weak against synonymy [7]. The fact that these axes are orthogonal is what makes our approach new. Gzip looks at global algorithmic regularity, while TF-IDF and Jaccard look at local token distributions. This multi-view fusion reduces the unique biases that are present in each modality, as shown by previous research on hybrid similarity [11].

Bias-Variance Tradeoff: The tripartite fusion protocol effectively readjusts the bias-variance tradeoff. Gzip reduces bias in out-of-distribution settings by taking advantage of universal compression properties, but it can still be affected by noise when there isn’t much data. TF-IDF, on the other hand, limits variance for in-distribution tasks by grounding term frequency strictly, but it introduces a lot of bias when vocabulary doesn’t match. Jaccard presents a structural prior predicated on set overlap, thereby stabilizing inference for sequences of moderate length. This synergy is similar to the theoretical basis for multi-metric ensembles [26], but EGTJ is very different from traditional methods. Instead of needing learned weights through training, EGTJ shows that a training-free majority-vote consensus among these carefully chosen orthogonal metrics is enough to beat supervised baselines in high-entropy (OOD) environments.

4. Approach

Figure 1 shows the EGTJ framework’s architectural schema. This method was created to get around the problems with current resource-constrained text classification methods, which rely on a lot of parameters and big labeled corpora. It introduces a new unsupervised, non-parametric synthesis. The system sets up an efficient pipeline by combining ES, gzip compression, TF-IDF, Jaccard similarity, and kNN classification.

Figure 1. Overview of the EGTJ pipeline. The offline phase (upper panel) builds an ES index from the training corpus. The online phase (lower panel) processes a test instance: ES retrieves top-m candidate documents; three similarity modules (gzip, TF-IDF, Jaccard) compute distances to the candidates; each module outputs a ranked list of top-k labels; labels are aggregated and a majority vote selects the final prediction.

The EGTJ framework’s operational workflow is split into two stages:

Stage 1: ES Index Construction. For each separate dataset (called DataSet i), the labeled corpus that goes with it is put into a special ES index called index i. This first step gets the system ready for high-speed retrieval by creating an inverted index structure that can rank results based on their relevance.

Stage 2: ES Retrieval and Label Voting. After processing a test instance t from DataSet i, the system runs a query against the ES index that goes with it. This operation makes a candidate set $S=[\mathrm{text}1,\dots ,\mathrm{text}m]$ of similar documents, each of which keeps its original class label. Three similarity-based modules—gzip + kNN, TF-IDF + kNN, and Jaccard + kNN—are then applied to the candidate set. Each module independently computes a ranked list of the top k predicted labels, resulting in a concatenated list of $3k$ labels: $L=[\mathrm{labg}1,\dots ,\mathrm{labgk},\mathrm{labt}1,\dots ,\mathrm{labtk},\mathrm{labj}1,\dots ,\mathrm{labjk}]$, where labgi, labti, and labji denote the labels predicted by the gzip, TF-IDF, and Jaccard modules, respectively.

Finally, a voting mechanism is applied to the aggregated label list L. Each label receives one vote per appearance, and the labels are ranked by their vote count in descending order. The top k labels with the highest votes are selected as the final classification result for the test instance t.

4.1. ES Index Construction

The first stage involves configuring and populating ES indices for each dataset to enable efficient retrieval. Below, this work detail the indexing pipeline and its parameters, which are critical for balancing recall and computational efficiency in downstream classification.

4.1.1. Index Configuration

The indexing pipeline adheres to the following architectural specifications:

Scoring Model: BM25 ranking is used (default in ES 7.8.1) with optimized parameters for text retrieval, such as $b=0.75$, and $k_1=1.2$.

Tokenization: The standard analyzer is applied, such as lowercasing, unicode text segmentation (splits on word boundaries), and stopword removal (English default) to reduce noise.

Index Structure: The schema is engineered to support dual-modality access: analyzed fields for full-text interrogation and keyword fields for exact-match filtering, implemented via the mapping {"mappings":{"properties":{"label":{"type":"text"},"text":{"type":"text"}}}}. System scalability and responsiveness are ensured through a 5-shard distribution for parallel query execution and a 1-second refresh interval.

4.1.2. Indexing Process

The procedural workflow for index generation is delineated in Algorithm 1. The sequence commences with the instantiation of an ES client, establishing a dedicated index for each dataset governed by the configuration parameters defined in Section 4.1.1. Subsequently, every training instance is serialized into a JSON object—encapsulating both class labels and textual content within the schema {“label”:“class_1”,“text”:“sample text…”}. The pipeline culminates in a bulk ingestion process, which enforces a 1-second refresh interval to guarantee near-real-time search availability while minimizing latency.

Algorithm 1 Creating ES index for the training data in dataset i

Require: Training data for a specific dataset i, denoted by A Ensure: ES index of training data for the dataset i   1: Initialize the ES client and connect to the ES cluster.   2: Create a new index in ES named index_i.   3: Define the mapping for the index, specifying the data fields and their respective data types.   4: for $t=0$ to $t=\mathrm{len}\left(A\right)$ do   5:      Construct JSON object: {“label”: $A\left[t\right]\left[“\mathrm{label}”\right]$, “text”: $A\left[t\right]\left[“\mathrm{text}”\right]$}.   6:      Index the JSON object document into the index_i.   7: end for   8: Once all documents in A have been indexed, refresh the index to make the documents searchable.   9: Disconnect the ES client from the ES cluster. 10: return index_i.

4.2. ES Retrieval and Label Voting

The inference architecture ends with an ES retrieval and voting system, which is fully explained in Algorithm 2.

Algorithm 2 Calculating the top-k labels for each text t in dataset i

Require: Testing data for dataset i, denoted by B; k: the number of labels to output; m: the number of records returned from ES retrieval. Ensure: The top-k labels of each text in dataset B.   1: Initialize $\mathrm{label}\_\mathrm{lists}\leftarrow \left[\right]$ to store the top-k labels.   2: for each text t in B do   3:       Initialize $\mathrm{votes}\leftarrow \left\{\right\}$.   4:       Retrieve from ES: $S\leftarrow [[{\mathrm{text}}_1,{\mathrm{lab}}_1],\dots ,[{\mathrm{text}}_m,{\mathrm{lab}}_m]]$.   5:       $L_g\leftarrow [{\mathrm{lab}}_{g1},\dots ,{\mathrm{lab}}_{gk}]\leftarrow \mathrm{gzip}+\mathrm{kNN}(t,S)$.   6:       $L_t\leftarrow [{\mathrm{lab}}_{t1},\dots ,{\mathrm{lab}}_{tk}]\leftarrow \mathrm{TF}\text{-}\mathrm{IDF}+\mathrm{kNN}(t,S)$.   7:       $L_j\leftarrow [{\mathrm{lab}}_{j1},\dots ,{\mathrm{lab}}_{jk}]\leftarrow \mathrm{Jaccard}+\mathrm{kNN}(t,S)$.   8:       $L\leftarrow \mathrm{Flatten}(L_g,L_t,L_j)$.   9:       for each label l in L do 10:             if l in votes then 11:                  $\mathrm{votes}\left[l\right]\leftarrow \mathrm{votes}\left[l\right]+1$ 12:             else 13:                  $\mathrm{votes}\left[l\right]\leftarrow 1$ 14:             end if 15:       end for 16:       Reverse sort votes based on vote count. 17:       $\mathrm{label}\_\mathrm{lists}.\mathrm{append}\left(\mathrm{votes}\right[:k\left]\right)$. 18: end for 19: return  $\mathrm{label}\_\mathrm{lists}$.

4.2.1. ES Retrieval Stage

Step 4 of Algorithm 2 is the retrieval logic. It starts by asking the pre-built ES index questions to find a set of documents that are related to the test instance t. There are two important parameters that control this operation: the target index identifier ($\mathrm{index}\_\mathrm{i}$) and the retrieval size m, which tells the system how many items to return in the result set.

A full-text search query is run to find the test instance t in the indexed training corpus. When the search engine gets the ES client, it uses its probabilistic ranking model (BM25) to figure out which records are most relevant and then filters the corpus to find the top-m records that are lexically similar.

The query gives back a payload of documents that were found, which includes both the raw text and the class labels that go with it. These results are subsequently parsed and stored in a candidate list: $S=\left[\right[\mathrm{text}1,\mathrm{lab}1],\dots [\mathrm{textm},\mathrm{labm}\left]\right]$, which is used as the input for the downstream similarity computation and label fusion steps.

4.2.2. Gzip + kNN Module

This module integrates the gzip lossless compression algorithm, a compression-based distance metric, and a kNN classifier, as illustrated in Figure 2.

Figure 2. gzip + kNN distance metric approach overview.

In terms of implementation, gzip is employed to compute a compression-based distance. Let $C\left(t1\right)$ denote the length of $t1$ after compression using gzip. Similarly, let $C\left(t1t2\right)$ represent the compressed length of the concatenation of texts $t1$ and $t2$. Based on the CLM, the distance between two texts can be calculated and subsequently used for classification via the kNN algorithm.

This module is efficiently implemented in Python using only 13 lines of code, as detailed in Algorithm 3. The input to the module includes the candidate document list $S=\left[\right[\mathrm{text}1,\mathrm{lab}1],\dots ,[\mathrm{textm},\mathrm{labm}\left]\right]$, the test sample $t1$, and the parameter k specifies the number of nearest neighbors considered for majority voting in the classification process.

Algorithm 3 Python Code for Text Classification with gzip + CLM + kNN

Require: $t_1$: The text to be classified in the test dataset; k: The number of labels to output; S: The similar text list returned from ES retrieval. Ensure: The top k labels of the text $t_1$.   1: import gzip   2: import numpy as np   3: $C_{t_1}\leftarrow$len(gzip.compress($t_1$.encode()))   4: distances ← [ ]   5: for ($t_2$, _) in S do   6:       $C_{t_2}\leftarrow$len(gzip.compress($t_2$.encode()))   7:       $t_{1,2}\leftarrow$ “”.join([$t_1$, $t_2$])   8:       $C_{t_1{t}_2}\leftarrow$len(gzip.compress($t_{1,2}$.encode()))   9:       $clm\leftarrow 1-{\displaystyle \frac{C_{t_1}+C_{t_2}-C_{t_1{t}_2}}{C_{t_1{t}_2}}}$ 10:       distances.append($clm$) 11: end for 12: $idx\leftarrow$np.argsort(np.array(distances)) 13: $topk\_label\leftarrow S\left[idx\right[:k],1]$ 14: return  $topk\_label$

4.2.3. TF-IDF + kNN Module

This module computes lexical similarity between the test text and the training samples using the TF-IDF representation. The top k most similar texts are then selected using cosine similarity, and their labels are used to determine the final classification.

The processing steps are as follows:

1.

Construct a vocabulary by extracting all unique words from the candidate document list $S=[\mathrm{text}1,\dots ,\mathrm{textm}]$.

2.

Compute the TF-IDF values for each text in S, resulting in a TF-IDF matrix where each row corresponds to a document and each column represents a word in the vocabulary.

3.

Apply the same preprocessing steps to the test text and compute its TF-IDF vector using the same vocabulary.

4.

Calculate the cosine similarity between the test vector and each row in the TF-IDF matrix. The cosine similarity between vectors A and B is given by:

$$\mathrm{cosine}\_\mathrm{similarity}(A,B)={\displaystyle \frac{A·B}{\parallel A\parallel ·\parallel B\parallel }},$$

(6)

Based on the calculated similarity scores, the k training samples that are most like the test text are chosen. In the next step of voting, their matching labels are used to make predictions about the candidates.

4.2.4. Jaccard + kNN Module

This module works on a strictly set-theoretic basis and gives more weight to the occurrence of binary tokens than to their frequency magnitude. Let t be the query instance and S be the pool of candidates that were found and contain labeled training examples.

The algorithmic workflow proceeds as follows:

1.

Preprocess all texts by normalizing and tokenizing them into sets of unique words.

2.

The system calculates the Jaccard coefficient for the query t against each document in S, which gives a number that shows the intersection-over-union ratio.

3.

The candidate pool S is reordered by descending similarity coefficient, isolating the nearest neighbors.

4.

Choose the k documents that are most like t, and then use majority voting to find out what t is by looking at the labels of these k neighbors.

This module introduces a structural similarity metric that is not affected by changes in frequency by removing term frequency and sequence order. This gives an orthogonal signal that works well with the statistical and information-theoretic modes of TF-IDF and gzip.

4.2.5. Integration Module

This module combines the predictions from the gzip + kNN, TF-IDF + kNN, and Jaccard + kNN modules using a weighted voting system that takes advantage of their strengths and improves the overall accuracy of the classification. The next parts make the voting strategy official and give reasons for why it works based on theory and evidence.

Voting Mechanism. For a given text t, each module makes a ranked list of the top k labels. Gzip captures information-theoretic similarity and outputs Lg = [labg1, …, labgk], TF-IDF captures lexical relevance and outputs Lt = [labt1, …, labtk], and Jaccard measures structural overlap and outputs Lj = [labj1, …, labjk]. To combine these outputs, the module fixes each one without slowing down the computer. The integration proceeds as follows.

1.

Flatten the outputs into a unified candidate label list: $L=Lg\cup Lt\cup Lj$.

2.

Count the frequency of each label in L to obtain the total number of votes per label.

3.

Sort the labels in descending order based on their vote counts.

4.

Select the top-k labels as the final prediction for the test instance.

An equal weighting scheme is employed, as ablation studies (see Section 5.3.5) indicate that it performs comparably to or better than learned weights while mitigating the risk of overfitting.

Theoretical and Empirical Justification. The bias-variance tradeoff principle guides the design of the integration module. For example, gzip makes OOD data more robust by using universal compression-based similarity, TF-IDF makes in-distribution data less variable by using word frequency statistics to make predictions, and Jaccard makes data more regular by using set-based overlap. This combination of orthogonal similarity measures helps models work better with different types of data. The integration is also non-parametric and doesn’t require training, which makes it scalable, adaptable, and computationally efficient—qualities that are important for use in environments with limited resources.

5. Experiment

5.1. Experimental Environment and Datasets

The experiments were conducted on a system running Ubuntu 20.04 with 16 GB of RAM, without requiring GPU resources. The main software and libraries used in this study include Python 3.8.5, Elasticsearch 7.8.1, and Gensim 4.0.0, all of which are lightweight, widely accessible, and easy to set up.

A diverse range of datasets was selected to examine how factors such as training sample size, class count, text length, and distributional differences influence classification accuracy. Table 1 summarizes these datasets, adapted from [8], the abbreviations are defined as follows: SN denotes the dataset abbreviation; NEtrain and NEtest correspond to the counts of examples in the training and test sets, respectively; NC specifies the total classes. Previous studies indicate that CNN- and RNN-based methods favor large datasets such as AGNews, while graph-based methods target smaller ones such as 20News, Ohsumed, R8, and R52 [1]. Addressing generalization on OOD datasets remains a challenge; Yu et al. [21] noted that improving in-distribution accuracy for pretrained models may degrade their OOD performance. To evaluate the proposed approach under realistic distribution shifts, this work selected four datasets that are OOD relative to the English-centric training corpora typically used in text classification benchmarks. Following the framework of Yang et al. [3], OOD data are defined as samples drawn from a distribution that differs systematically from the training distribution in terms of language, domain, vocabulary, and/or topic. The selected OOD datasets-KinyarwandaNews, KirundiNews, DengueFilipino, and SwahiliNews-exhibit the following shifts: (1) cross-lingual shift (Bantu languages and Filipino not covered by standard English pretraining corpora), and (2) domain-vocabulary shift (e.g., public health terminology in DengueFilipino).

Table 1. Specifics of the assessment datasets.

Dataset	SN	NEtrain	NEtest	NC	NW	NL	VS
AGNews	AGN	120 K	7.6 K	4	44	236	128 K
20News	20N	11 K	7.5 K	20	406	1902	277 K
Ohsumed	Ohs	3.4 K	4 K	23	212	1273	55 K
R8	R8	5.5 K	2.2 K	8	102	587	24 K
R52	R52	6.5 K	2.6 K	52	110	631	26 K
KinyarwandaNews	Kin	17 K	4.3 K	14	232	1872	240 K
KirundiNews	Kir	3.7 K	923	14	210	1722	63 K
DengueFilipino	DeF	4 K	500	5	10	62.7	13 K
SwahiliNews	Swa	22.2 K	7.3 K	6	327	2.2 K	570 K

In terms of data preprocessing, all datasets underwent a uniform preprocessing pipeline: texts were cleaned (HTML/URL removal, lowercasing), tokenized via whitespace splitting, and English stopwords were removed for English datasets. Digits were replaced with a special token, and extra whitespace was collapsed. For TF-IDF, a vocabulary was built from the training split with a minimum document frequency of 1. The preprocessed text (after cleaning and lowercasing) is indexed using the standard analyzer as described in Section 4.1, which performs its own tokenization and stopword filtering for retrieval purposes. The same preprocessing was applied consistently to training and test sets without task-specific tuning.

These datasets are intentionally chosen to test vocabulary, syntactic, and topical distributional shifts—key challenges in real-world deployment. Table 1 summarizes their statistical properties, including vocabulary size (VS), average word count (NW), and character count (NL). The large vocabulary differences (e.g., 570 K for SwahiliNews vs. 128 K for AGNews) highlight the lexical shift, while variations in average text length reflect structural differences.

5.2. Baselines and Implementation Details

The results of this study are evaluated against two types of methods: (1) neural network-based approaches requiring training and (2) non-parametric approaches utilizing the kNN classifier, either directly or with pre-training on external data. For text classification, this work especially consider widely adopted architectures, including logistic regression, fastText [27], RNNs with and without attention mechanisms (such as bidirectional LSTMs [28] enhanced by attention [29], and hierarchical attention networks [30]), CNNs (e.g., character-level CNNs [16], recurrent CNNs [31], and deep CNNs [32]), as well as BERT [20]. Additionally, three other non-parametric techniques, such as word2vec (W2V) [33], pretrained sentence BERT (SentBERT) [34], and gzip [8] are incorporated in the comparison.

For all baseline models, this study adopt the same hyperparameter settings as described in [8] for both the full-dataset and few-shot settings. All experiments adhere to the predefined training/test splits listed in Table 1. For few-shot settings, labeled examples are randomly sampled from the training set, and results are averaged over five independent runs with different random seeds to ensure statistical reliability. For the proposed method, the only hyperparameters are the ES retrieval size (m) and the kNN classifier size (k). During the empirical evaluation, this study implemented a consistent hyperparameter schema, establishing the retrieval size at $m=20$ and $k=2$, and documenting the maximum accuracy achieved under these parameters. When it comes to computational throughput, inference on the AGNews corpus takes about 130 s, and for larger datasets, it takes about 800 s. The OOD assessments strictly followed a zero-adaptation protocol, which meant that models were only trained on the in-distribution source domains listed in Table 1. This made sure that there was no gradient fine-tuning or statistical exposure to the target OOD environments.

5.3. Results and Analysis

5.3.1. Results and Analysis on In-Distribution Datasets

Table 2 shows a real-world landscape that helps us understand how well the architectures we looked at work on the AGNews, 20News, Ohsumed, R8, and R52 benchmarks. EGTJ is different from traditional models that require a lot of computation for pre-training or iterative gradient descent because it uses a strictly non-parametric, training-free approach. This architectural independence makes it much easier to deploy high-resource models, so there’s no need for complicated data curation or special hardware. Quantitative analysis shows that EGTJ sets a new record on the AGNews corpus with an accuracy of 0.966, which is better than both supervised and pre-trained baselines. Even when fine-tuned BERT models are slightly better—specifically on 20News and R52—EGTJ comes close to this level of performance with very small differences of 0.001 and 0.009, respectively. In addition, the results support the idea that the proposed hybrid fusion strategy effectively cancels out the differences that are naturally present in single-modality similarity metrics. This is shown by the fact that it achieved top-tier accuracy on R8 (0.985) and matched the fidelity of heavy Transformer architectures in other places.

Table 2. Test accuracy comparison with the proposed method, including previously published results for all baseline models from [8].

Model	AGNews	20News	Ohsumed	R8	R52
TFIDF+LR	0.898	0.827	0.549	0.949	0.874
LSTM	0.861	0.657	0.411	0.937	0.855
Bi-LSTM+Attn	0.917	0.667	0.481	0.943	0.886
HAN	0.896	0.646	0.462	0.960	0.914
charCNN	0.914	0.401	0.269	0.823	0.724
textCNN	0.817	0.751	0.570	0.951	0.895
RCNN	0.912	0.716	0.472	0.810	0.773
VDCNN	0.913	0.491	0.237	0.858	0.750
fastText	0.911	0.690	0.218	0.827	0.571
BERT	0.944	0.868	0.741	0.982	0.960
W2V	0.892	0.460	0.284	0.930	0.856
SentBERT	0.940	0.778	0.719	0.947	0.910
gzip	0.937	0.685	0.521	0.954	0.896
EGTJ (Ours)	0.966	0.867	0.652	0.985	0.951

5.3.2. Results and Analysis on Out-of-Distribution Datasets

Figure 3 shows the results of the empirical evaluation on OOD datasets, and Table 3 shows more detailed metrics. As shown, EGTJ always gets better average accuracy than baseline architectures in the KinyarwandaNews, KirundiNews, DengueFilipino, and SwahiliNews corpora, whether in full-shot or 5-shot scenarios. To ensure that the few-shot experiments were statistically sound, labeled examples were randomly chosen from a fixed set of five different seeds (0–4) and used the same way for all models. This strong performance shows how flexible and general the framework is, especially in situations where there isn’t a lot of data. This success can likely be attributed to its feature extraction and fusion mechanisms work together in a smart way that lets the model find useful signals in small amounts of observational data.

Figure 3. Comparison of accuracy of different models on full-shot and five-shot scenario using the OOD datasets. The symbol “#” denotes the number of labeled examples per class.

Table 3. Test accuracy in a full-shot and five-shot scenario using OOD datasets, with a 95% confidence interval over five trials.

Model/Dataset	KinyarwandaNews		KirundiNews		DengueFilipino		SwahiliNews
Shot #	Full	5-Shot	Full	5-Shot	Full	5-Shot	Full	5-Shot
Bi-LSTM+Attn	0.843	0.253	0.872	0.254	0.948	0.369	0.863	0.357
HAN	0.820	0.137	0.881	0.190	0.981	0.362	0.887	0.264
fastText	0.869	0.170	0.883	0.245	0.870	0.248	0.874	0.347
W2V	0.874	0.281	0.904	0.288	0.993	0.481	0.892	0.373
SentBERT	0.788	0.292	0.886	0.314	0.992	0.629	0.822	0.436
BERT	0.838	0.240	0.879	0.386	0.979	0.409	0.897	0.396
gzip	0.891	0.458	0.905	0.541	0.998	0.652	0.927	0.627
EGTJ (ours)	0.934	0.590	0.928	0.690	0.983	0.701	0.961	0.745

The symbol “#” in the column header “Shot#” denotes the number of labeled examples per class used in the few-shot experiments.

Comparative analysis shows that there is a lot of variation in performance across datasets. This is probably because the model architecture interacts with the specific characteristics of the data. Table 4 shows that EGTJ has better average test accuracy than all the other methods. The framework is not only very accurate, but it is also very fast and easy to use. It doesn’t need any pre-training or gradient optimization. This makes EGTJ a very powerful tool for text classification that is a good alternative to deep learning models. It’s worth noting that the standalone gzip model gets almost perfect accuracy (0.998) in the full-shot DengueFilipino scenario, but EGTJ does better in the harder 5-shot setting. The fact that DengueFilipino and SwahiliNews do better than KinyarwandaNews and KirundiNews in 5-shot tests suggests that the datasets are inherently different in terms of how hard they are to work with.

Table 4. Comparison of test accuracy between EGTJ and the average of all baseline models.

Dataset	Average	EGTJ (Ours)
AGNews	0.904	0.966
20News	0.664	0.867
Ohsumed	0.456	0.652
R8	0.913	0.985
R52	0.836	0.951

Concerning model characteristics, sequence-dependent models like Bi-LSTM+Attn and HAN exhibit significant degradation in the 5-shot scenario, presumably due to their dependence on extensive temporal contexts that are not present in the few-shot scenario. On the other hand, fastText and Word2Vec are moderately resilient, which shows that static word embeddings can be useful for low-resource learning. Pre-trained Transformers like SentBERT and BERT improve accuracy through contextual transfer, but EGTJ always does better in the important 5-shot OOD context. Even when compared to the strong baseline of pure gzip compression, EGTJ shows better fidelity in both full-shot and few-shot scenarios. This supports the idea that a hybrid fusion strategy makes feature extraction more robust.

When it comes to model characteristics, sequence-dependent models like Bi-LSTM+Attn and HAN do much worse in the 5-shot scenario. This is likely because they rely on long-term temporal contexts that aren’t present in the few-shot scenario. FastText and Word2Vec, on the other hand, are somewhat resilient. This shows that static word embeddings can be helpful for learning with few resources. Pre-trained Transformers like SentBERT and BERT make things more accurate by transferring context, but EGTJ always does better in the important 5-shot OOD context. EGTJ has better fidelity in both full-shot and few-shot situations, even when compared to the strong baseline of pure gzip compression. This backs up the idea that a hybrid fusion strategy makes it easier to get features out of data.

EGTJ is very effective at few-shot learning, and in the 5-shot scenario, it had the highest accuracy of all the OOD datasets that were tested. These results highlight the essential importance of integrating various feature extraction modalities and confirm the requirement for generalization-oriented architectures to manage heterogeneous data distributions.

5.3.3. Few-Shot Learning

This study used the AGNews, DBpedia, and SogouNews corpora to compare EGTJ to a range of deep learning architectures in a few-shot learning framework to rigorously test its effectiveness in situations where data is scarce. We divided these datasets into groups based on how many records they had and how many languages they spoke to make it possible to evaluate them up to the 100-shot mark. For the experiments, we randomly chose n-shot labeled examples from each class, where n was one of the following: 5, 10, 50, or 100. The comparative cohort includes a wide range of parameter complexity, from parameter-free compression models (gzip) to minimal-parameter embeddings (Word2Vec, Sentence-BERT) and n-gram baselines (fastText), as well as word-based neural architectures like HAN.

Figure 4 shows the different performance paths, while Table 5, Table 6 and Table 7 give more detailed information. EGTJ always does better than non-pretrained neural baselines (like Bi-LSTM+Attn and HAN) and the standard gzip model at all shot horizons. In the extreme 5-shot setting, EGTJ gets an accuracy of $0.657\pm 0.020$, which is 7% better than gzip, its closest competitor without parameters. This path of better effectiveness continues through the 10-, 50-, and 100-shot increments, which shows that the framework is strong in environments with little supervision.

Figure 4. Comparing several techniques with varying shots# (where “#” indicates the number of labeled examples per class) and a 95% confidence interval across five trials.

Table 5. Few-shot results on AGNews.

Model/Dataset	5-Shot	10-Shot	50-Shot	100-Shot
Bi-LSTM+Attn	${0.269}_{\pm 0.022}$	${0.331}_{\pm 0.028}$	${0.549}_{\pm 0.028}$	${0.665}_{\pm 0.019}$
HAN	${0.274}_{\pm 0.024}$	${0.289}_{\pm 0.020}$	${0.340}_{\pm 0.073}$	${0.548}_{\pm 0.031}$
fastText	${0.273}_{\pm 0.021}$	${0.329}_{\pm 0.036}$	${0.550}_{\pm 0.008}$	${0.684}_{\pm 0.010}$
W2V	${0.388}_{\pm 0.186}$	${0.546}_{\pm 0.162}$	${0.531}_{\pm 0.272}$	${0.395}_{\pm 0.089}$
SentBERT	${\mathbf{0.716}}_{\pm 0.032}$	${\mathbf{0.746}}_{\pm 0.018}$	${0.818}_{\pm 0.008}$	${0.829}_{\pm 0.004}$
gzip	${0.587}_{\pm 0.048}$	${0.610}_{\pm 0.034}$	${0.699}_{\pm 0.017}$	${0.741}_{\pm 0.007}$
EGTJ (Ours)	${0.657}_{\pm 0.020}$	${0.707}_{\pm 0.008}$	${\mathbf{0.826}}_{\pm 0.005}$	${\mathbf{0.862}}_{\pm 0.008}$

Table 6. Few-shot results on DBpedia.

Model/Dataset	5-Shot	10-Shot	50-Shot	100-Shot
Bi-LSTM+Attn	${0.506}_{\pm 0.041}$	${0.648}_{\pm 0.025}$	${0.818}_{\pm 0.008}$	${0.862}_{\pm 0.005}$
HAN	${0.350}_{\pm 0.012}$	${0.484}_{\pm 0.010}$	${0.501}_{\pm 0.003}$	${0.835}_{\pm 0.005}$
fastText	${0.475}_{\pm 0.041}$	${0.616}_{\pm 0.019}$	${0.767}_{\pm 0.041}$	${0.868}_{\pm 0.014}$
W2V	${0.325}_{\pm 0.113}$	${0.402}_{\pm 0.123}$	${0.675}_{\pm 0.050}$	${0.787}_{\pm 0.015}$
SentBERT	${0.730}_{\pm 0.008}$	${0.746}_{\pm 0.018}$	${0.819}_{\pm 0.008}$	${0.829}_{\pm 0.004}$
gzip	${0.622}_{\pm 0.022}$	${0.710}_{\pm 0.021}$	${0.825}_{\pm 0.003}$	${0.857}_{\pm 0.004}$
EGTJ (Ours)	${\mathbf{0.757}}_{\pm 0.026}$	${\mathbf{0.825}}_{\pm 0.019}$	${\mathbf{0.911}}_{\pm 0.012}$	${\mathbf{0.936}}_{\pm 0.003}$

Table 7. Few-Shot results on SogouNews.

Model/Dataset	5-Shot	10-Shot	50-Shot	100-Shot
Bi-LSTM+Attn	${0.534}_{\pm 0.042}$	${0.614}_{\pm 0.047}$	${0.771}_{\pm 0.021}$	${0.812}_{\pm 0.008}$
HAN	${0.425}_{\pm 0.072}$	${0.542}_{\pm 0.118}$	${0.671}_{\pm 0.102}$	${0.808}_{\pm 0.020}$
fastText	${0.545}_{\pm 0.053}$	${0.652}_{\pm 0.051}$	${0.782}_{\pm 0.034}$	${0.809}_{\pm 0.012}$
W2V	${0.141}_{\pm 0.005}$	${0.124}_{\pm 0.048}$	${0.133}_{\pm 0.016}$	${0.395}_{\pm 0.089}$
SentBERT	${0.485}_{\pm 0.043}$	${0.501}_{\pm 0.041}$	${0.565}_{\pm 0.013}$	${0.572}_{\pm 0.003}$
gzip	${0.649}_{\pm 0.061}$	${0.741}_{\pm 0.017}$	${0.833}_{\pm 0.007}$	${0.867}_{\pm 0.016}$
EGTJ (Ours)	${\mathbf{0.797}}_{\pm 0.043}$	${\mathbf{0.868}}_{\pm 0.024}$	${\mathbf{0.903}}_{\pm 0.012}$	${\mathbf{0.917}}_{\pm 0.005}$

As the supervision signal gets stronger, EGTJ shows that its performance is getting closer to that of heavy, pre-trained architectures. In the 100-shot setting of the AGNews dataset, the framework gets an accuracy of $0.862\pm 0.008$, which is better than SentBERT’s $0.829\pm 0.004$. This parity is especially important because the computational overhead is not the same; EGTJ provides competitive fidelity without the huge amounts of data and pre-training cycles that Transformer-based encoders need. Further analysis shows that the framework is better in real-world 5-shot OOD situations. Table 3 shows that EGTJ performs much better than deep learning methods. In particular, EGTJ shows accuracy gains of 145.8%, 78.7%, 71%, and 88% across the four OOD datasets when compared to BERT. Also, it beats the standalone gzip baseline by 29%, 27.5%, 7.5%, and 18.8%, respectively.

This work attribute this dominance in few-shot situations is because compression algorithms provide intrinsic regularization that effectively captures structural regularities when there isn’t enough labeled data for gradient convergence. Also, the synergistic combination of orthogonal feature extraction methods makes inference more stable, which lowers the risk of overfitting that deep neural networks often face when there isn’t enough data.

5.3.4. Time Performance Evaluation

This section measured the inference latency of EGTJ against the standard gzip baseline across the full dataset spectrum to see how well the proposed architecture worked. Figure 5 shows how the two systems compare over time. The real-world data shows that EGTJ always gives better throughput. This speedup is most noticeable on large corpora like AGNews, 20News, and SwahiliNews, where the proposed method cuts processing time by orders of magnitude compared to the exhaustive compression baseline. EGTJ still has a big latency advantage even with medium-sized datasets like Ohsumed, R8, R52, and KinyarwandaNews.

Figure 5. Test time performance on all datasets (unit: second).

This analysis underscores the algorithmic efficiency of the EGTJ framework. By drastically curtailing computational overhead, the model not only offers a viable solution for real-time text processing but also enables scalable data analytics within resource-constrained environments previously inaccessible to pure compression-based methods.

5.3.5. Results and Analysis on Ablation Experiment

We did a full ablation study to systematically test how well each module in the EGTJ framework worked on its own. This study compared the full architecture to four different structural variants and a weighted voting option across the entire dataset spectrum. The empirical results are summarized in Table 8.

Table 8. Test accuracy results for the EGTJ model and its ablation variants.

Model/Dataset	AGN	20N	Ohs	R8	R52	Kin	Kir	DeF	Swa
EGTJ w/o JG	0.931	0.822	0.645	0.934	0.900	0.900	0.931	0.925	0.895
EGTJ w/o GT	0.939	0.796	0.529	0.969	0.923	0.902	0.920	0.931	0.928
EGTJ w/o JT	0.947	0.817	0.575	0.965	0.922	0.910	0.920	0.962	0.930
EGTJ w/o J	0.960	0.855	0.631	0.981	0.945	0.928	0.928	0.977	0.953
EGTJ-Weighted	0.964	0.863	0.648	0.983	0.949	0.932	0.925	0.980	0.958
EGTJ	0.966	0.867	0.652	0.985	0.951	0.934	0.928	0.983	0.961

EGTJw/oJ: Excludes Jaccard similarity.

EGTJw/oJG: Excludes Jaccard + gzip.

EGTJw/oJT: Excludes Jaccard + TF-IDF.

EGTJw/oGT: Excludes gzip + TF-IDF.

EGTJ-Weighted: Replaces equal voting with learned weights (optimized per dataset).

The results clearly show that the full EGTJ architecture is better than any of the ablated versions, with performance margins of 2.1% to 12.3%. When the gzip + TF-IDF subsystem was removed from the Ohsumed dataset, the accuracy dropped sharply from 65.2% to 52.9%. This shows how important this synergistic fusion is. The gzip and TF-IDF modules are the most important parts, and taking them out lowers performance by an average of 6.4%. On the other hand, the Jaccard module is an important stabilizer that improves accuracy by 3.1% on the SwahiliNews dataset.

Comparisons with a weighted voting variant resulted in minimal enhancements over the standard equal-weight consensus, thereby affirming the parsimony of the proposed unweighted design. Granular analysis reveals domain-specific dependencies: the TF-IDF + Jaccard combination prevails in medical contexts (Ohsumed), while the gzip + Jaccard pairing is adequate for short-text classification (DengueFilipino). The full model is very strong in OOD situations, where leaving out Jaccard or TF-IDF only caused a small drop (≤1.5%), but leaving out gzip caused a big drop (≤8.9%). This difference shows that the framework’s ability to generalize is mainly due to the balanced integration of orthogonal metrics.

5.3.6. Impact of ES Retrieval Size on Downstream Performance

This section performed a systematic sensitivity analysis of the ES candidate set size (m) to empirically ascertain the optimal retrieval horizon, evaluating its dual influence on classification accuracy and computational efficiency. Table 9 shows the important trade-offs in performance that were seen in two datasets that are typical of the kinds of data we work with.

Table 9. Accuracy and Time per Query for different datasets and m sizes.

Dataset	m size	Accuracy	Time/Query (ms)
AGNews	10	0.953	20.4
	20	0.966	27.9
	30	0.964	36.5
	40	0.966	42.7
	50	0.966	51.7
KirundiNews	10	0.916	32.1
	20	0.928	65.1
	30	0.926	96.2
	40	0.926	113.3
	50	0.928	152.2

The experimental data show that $m=20$ is the point of inflection where predictions are most accurate and take the least time to make. In particular, setting $m=20$ on the AGNews benchmark gives an accuracy of 96.6%, which is the same as the $m=50$ setting, and it cuts the time it takes to run a query by 86%. The model also gets 92.8% accuracy on the KirundiNews dataset at $m=20$, which is the same as the $m=50$ baseline but with a 2.3× faster inference speed. If the retrieval horizon is set to more than $m=20$, the accuracy doesn’t get much better, but the cost of computing goes up in a straight line.

6. Conclusions

6.1. Limitations

EGTJ is accurate and works well, but it does have some issues. Keeping up with ES indices takes up more memory and storage space. Even though ES pre-filtering speeds up retrieval, it might be necessary to use it on more than one server to handle very large corpora, like hundreds of millions of documents. EGTJ is a non-parametric method, so it doesn’t directly model semantics. This could make it harder to do tasks that require a deep understanding of context. These limits make it more likely that more extensions will be made and point to useful deployment factors.

6.2. Conclusions and Future Work

This study introduces EGTJ, an effective unsupervised framework that integrates ES, gzip compression, TF-IDF, and Jaccard similarity into a cohesive AI-NLP pipeline for text classification in resource-constrained environments. EGTJ meets the need for lightweight, training-free, and strong systems that can work with limited data and computing power by combining classical retrieval and similarity metrics. Extensive experimental results validate that the proposed EGTJ framework not only achieves superior classification accuracy over both traditional baselines and pre-trained models across in-distribution, OOD and few-shot learning scenarios, but also delivers significantly improved computational efficiency by virtue of the ES pre-filtering strategy.

Future work will focus on hybrid neural-classical compression to enhance semantic understanding while preserving efficiency, together with adaptive metric weighting to improve generalization across diverse data distributions. These improvements are meant to make the framework less sensitive and fill in semantic gaps while keeping its main computational benefits. This makes it a useful option for real-world use and helps to make AI-powered NLP tools more accessible.