A Meta-Contrastive Optimization Framework for Multilabel Bug Dependency Classification

Abstract

Software maintenance and release management demand proper identification of bug dependencies since priority violations or unresolved dependent issues can often lead to a chain of failures. However, dependency annotations in bug reports are extremely sparse and imbalanced. These dependencies are often expressed implicitly through natural language descriptions rather than explicit metadata. This creates challenges for automated multilabel dependency classification systems. To tackle these drawbacks, we introduce a meta-contrastive optimization framework (MCOF). This framework integrates established learning paradigms to enhance transformer-based classification through two key mechanisms: (1) a meta-contrastive objective adapted for enhancing discriminative representation learning under few-shot supervision, particularly for rare dependency types, and (2) dependency-aware Laplacian regularization that captures relational structures among different dependency types, reducing confusion between semantically related labels. Experimental evaluation on a real-world dataset demonstrates that MCOF achieves significant improvement over strong baselines, including BM25-based clustering and standard BERT fine-tuning. The framework attains a micro-F1 score of 0.76 and macro-F1 score of 0.58, while reducing hamming loss to 0.14. Label-wise analysis shows significant performance gain on low-frequency dependency types, with improvements of up to 16% in F1 score. Runtime analysis exhibits only modest inference overhead at 15%, confirming that MCOF remains practical for deployment in CI/AT pipelines. These results demonstrate that integrating meta-contrastive learning and structural regularization is an effective approach for robust bug dependency discovery. The framework provides both practical and accurate solutions for supporting real-world software engineering workflows.

1. Introduction

Dependent bug analysis plays an important role in issue management and release planning on software projects [1,2]. Unresolved dependency chains can cause cascading failures that delay projects indefinitely because fixing one bug often requires resolving another dependent bug first [3]. Bugzilla and Jira include issue tracker features such as ‘blocks’ or ‘depends on’ to help developers visualize and track the structured relationships between issues [1,4]. However, these dependencies are mostly assigned manually, leading to incomplete annotations, inconsistencies and significant delay [5,6]. As a result, automating dependency identification from bug reports has become essential for state-of-the-art software maintenance practices [7,8,9].

Early approaches usually relied on unsupervised learning and information retrieval techniques. For instance, Luaphol et al. [8] utilized BM25 similarity to cluster-dependent bug reports around meta-bugs based on a fixed similarity threshold, illustrating that it was feasible to assemble dependencies automatically without labeled data [8,9]. While this approach is cost-effective, it is limited to coarse-grained lexical analysis. It often leads to errors by linking semantically unrelated words during symptom identification in textual bug descriptions [10,11,12]. Unsupervised clustering also struggles to handle multilabel dependence types, making it ineffective at distinguishing subtle relation subtypes (e.g., blocks versus related) [13,14]. Overall, the lack of semantic modeling and dependency structure understanding shows poor performance, especially for rare dependency labels that are important in practice [13,14,15].

Recently, advances in natural language processing (NLP) and deep learning have strengthen the effectiveness of supervised text classification-based techniques for exploring semantic information from bug reports [16,17,18]. Transformer-based models such as BERT and RoBERTa learn contextualized representations of text and have delivered promising results in tasks such as bug triaging and severity prediction. However, existing supervised approaches have not fully examined multilabel classification for dependency, where a single bug can correspond to multiple types of dependency at once [16,19]. Two main challenges occur: (1) imbalanced label distribution, where certain dependency types are severely underrepresented and (2) weak structure modeling between dependency labels, such that their co-occurrence and relational semantics are neglected [20,21,22].

These restrictions point to a clear research gap. Current methods for dependency identification rely either on unsupervised lexical-similarity clustering, which lacks semantic awareness, or on supervised text classification, which does not explicitly consider the multilabel structure of dependencies nor maximize performance for rare relational types [20,23,24]. These limitations make it difficult to automatically discover complex dependency relationships between software bugs, especially when subtle semantic clues or multiple co-existing dependencies are involved [7,9,24,25].

We address this research gap through a novel integration of meta-learning and contrastive optimization specifically designed for multilabel bug dependency classification. Our framework systematically integrates established learning paradigms while providing empirical validation of performance robustness under conditions of severe label imbalance. While the individual components have been investigated independently in prior studies, their systematic integration within a unified meta-contrastive optimization framework and comprehensive evaluation for fine-grained bug dependency classification remain underexplored. Instead of relying on a single learning objective, the proposed method combines transformer-based embeddings of bug titles and descriptions to capture the rich context semantics [9]. A meta-contrastive loss is used to attract semantically related bug reports and repel unrelated samples in the latent space [26]. In particular, meta-learning strategies are utilized to address the extreme scarcity of certain dependency types. By treating different label subgroups as distinct tasks, the framework promotes robust optimization even for “tail” classes with very few training examples. To further cope with the highly imbalanced label distribution, especially for low-frequency types that are operationally important dependency types, an imbalance-aware regularization term is incorporated into the optimization criterion [9]. Moreover, dependence-aware structural regularization, based on optional graph constraints from label co-occurrence pattern, helps the model capture label correlations, leading to more robust multilabel prediction. Therefore, dependency classification is formulated as a fully supervised, semantics-driven multilabel learning problem, supported by a theoretically sound optimization framework.

The objective of this study is to demonstrate that supervised semantic learning offers statistically significant improvements over unsupervised dependency kit-assembly for recognizing text-based dependencies, ultimately providing fine-grained support for real-world development cycles. More importantly, the project aims to develop a powerful multilabel dependency classifier that can significantly enhance prediction results for rare relational types and provide an integrated solution that effectively combines the semantic representation learning and the dependency structure modeling in bug repositories. Anticipated results include a significant improvement in macro-F1 and label-wise predictions performance as compared to unsupervised BM25-based baseline. Thus, it demonstrates the importance of semantic modeling for better and more intelligent dependency history learning in practice.

To summarize, this work contributes to automated dependency type classification, including the following: (i) the first direct comparison between unsupervised syntactic assembly of dependencies and supervised semantic multilabel learning; (ii) a unified integration of Reptile-based meta-learning and supervised contrastive learning, empirically validated for improving rare dependency prediction under severe label imbalance; and (iii) substantial performance gains on low-frequency dependency labels achieved through imbalance-aware techniques and dependency-sensitive regularization. Together, these contributions advance the field of bug dependency management in evolving software applications.

The remainder of this paper is organized as follows. Section 2 describes the dataset and its characteristics. Section 3 details the proposed methodology. Section 4 presents the experimental results and analysis. Finally, Section 5 concludes the paper and discusses potential future work.

2. Bug Report Dataset and Dependency Annotation

2.1. Data Source and Annotation

The dataset used in our study was compiled from real-world bug reports scraped from the Bugzilla platform, primarily focusing on Mozilla Firefox project. All reports were obtained from publicly accessible development repositories, ensuring data reproducibility and transparency. To ensure the reliability of our dependency data, only bugs marked as “verified” or “closed” were considered. These bugs were further inspected and validated by software developers or triagers. Therefore, the dependency annotations reflect expert-driven knowledge rather than purely heuristic assumptions.

Every bug report in our dataset comprises three main components: (1) a brief description of the main symptoms, (2) a complete problem statement, and (3) comments from the ongoing discussion during diagnosis and repair.

Based on previous works [8,9,27,28], the summary and description fields are the most useful sources of semantic information for identifying dependencies, as they tend to minimize the noise introduced by comments. Consequently, these two textual fields are selected as the main input features for our models.

Importantly, bugs participate in multiple dependency relationships simultaneously. A single bug report might block several other issues while also depending on additional root issues. This characteristic transforms the couple of class-labels for dependence classification into a multilabeling problem that better reflects the complex interdependencies found in real software development and dependency management. Given the annotation schema used in BM25 clustering, each bug report is associated with one to four dependency relations, forming a directed acyclic dependency structure where meta-bugs serve as parent nodes imposing constraints on related issues.

The dataset contains a total of 4781 annotated bug reports covering 200 dependency centers. A summary of the dataset is provided in

Table 1. Summary of dataset used.

Property	Description
Source	Bugzilla, Mozilla Firefox
Total reports	4781
Meta-bug reports	200
Dependency labels	1–4 multilabel per report
Text fields used	Summary + Description
Annotation origin	Verified by bug triagers
Validation	10-fold cross-validation
Data issue	Imbalanced label distribution

. All annotations were manually verified by expert triagers, establishing these labels as ground-truth expert annotations; therefore, this dataset is very reliable for the evaluation of contemporary dependency mining methods. Figure 1 and Figure 2 are examples of a bug report.

A significant characteristic of this dataset is its severe class imbalance. Certain dependency types that are rare but critical have insufficient samples, while common relations dominate the data. The class imbalance usually resulted in poor recall and low macro-F1 score. Overcoming this limitation is the key motivation for our research.

Finally, to ensure a fair and unbiased comparison with the baseline unsupervised BM25-based dependency clustering method, we adopted the same standard 10-fold cross-validation protocol employed in baseline studies, thus preventing test leakage or re-standardization.

2.2. Label Distribution and Imbalance Characteristics

To gain a deeper insight into the learning challenges for multilabel bug dependency classification, we explore the distribution of annotated dependency relations in our dataset. As shown in

Table 2. Distribution of dependency labels.

Dependency Type	Samples	Percentage
Blocks	2650	55.4%
Depends-On	1550	32.4%
Related-To	400	8.4%
Triaged-By-Meta-Bug	181	3.8%
Total	4781	100%

, the data follows a long-tail distribution, with majority blocks dependency types comprising 55.4% of the annotations, while minority Triaged-By-Meta-Bug dependency types only account for less than 4%. This severe imbalance tends to skew the performance of supervised models towards high-support dependency categories, preventing them from effectively generalizing to rare, yet crucially important, relationships.

These low-frequency labels often correspond to high-priority issues that require significant developer coordination. Consequently, their impact on release planning is disproportionately high. Hence, it is necessary to enhance the predictive accuracy of these sparse relations in real-world software maintenance applications. This imbalance provides the important practical motivation for our evaluation strategy, macro-F1 and hamming loss metrics are prioritized. These metrices better capture performance on minority dependency types and error sensitivity in multilabel settings, instead of relying solely on common micro-level performance on minority dependency types. As a result, the proposed meta-contrastive optimization framework is particularly designed to mitigate representation bias and enhance semantic discrimination under these challenging imbalance conditions.

3. The Proposed Method

In this section, we describe the architecture of the meta-contrastive optimization framework. The framework combines multiple learning techniques to address data sparsity challenges in multilabel bug dependency classification. The main components of the pipeline are (1) preprocessing and transformer-encoder-based representation learning, followed by (2) multilabel classification; (3) cyclic optimization between contrastive adaptation and supervised multilabel training; as well as regularizers that seek to make labeling decisions invariant to class imbalance and label-dependency structure.

3.1. Problem Formulation and Notation

Let $\mathcal{D}={\left\{\left(x_i,y_i\right)\right\}}_{i=1}^N$ denote the set of bug reports, where x_i is the textual content of bug i, and ${\mathrm{y}}_{\mathrm{i}}\in {\left\{0, 1\right\}}^L$ is a multilabel vector over L dependency types (e.g., blocks, depends on, related to). Each report x_i is constructed by concatenating the summary and description fields from Bugzilla, which provide the most informative semantic cues for dependency recognition while avoiding noisy discussion comments. This goal is to learn a mapping.

$$f_{\theta }:x_i\to z_i\in {\mathbb{R}}^d, g_{\varphi }:z_i\to {\widehat{y}}_i\in {\left[0, 1\right]}^L$$

(1)

where $f_{\theta }$ is a transformer-based encoder producing a dense representation z_i, and $g$_ϕ is a multilabel classification head that outputs per-label probabilities ${\widehat{y}}_i$. The model is trained so that ${\widehat{y}}_i$ approximates the ground-truth dependency vector y_i, while a contrastive objective shapes the embedding space to respect semantic similarity and dependency relations.

3.2. Text Preprocessing and Transformer-Based Encoding

3.2.1. Text Preprocessing

For each bug report, the summary and description are concatenated into a single sequence, standard NLP preprocessing is applied (Unicode normalization followed by lowercasing [29]), and the text is tokenized using a subword tokenizer from a pre-trained transformer (e.g., BERT or MPNet) [30,31]. Sequences are truncated or padded to the same (up to a limit) maximum length T tokens [32].

3.2.2. Transformer Encoder

The tokenized sequence is fed to a pre-trained transformer encoder $f_{\theta }$. Let $H_i\in {\mathbb{R}}^{T\times d}$ denote the sequence of hidden states. The pooled representation (e.g., the [CLS] token or mean pooling) is used as the bug embedding [33,34,35]:

$$z_i=f_{\theta }(x_i)\in {\mathbb{R}}^d$$

(2)

To stabilize contrastive learning, we normalize embeddings:

$${\tilde{z}}_i=\frac{z_i}{{||z_i||}_2}$$

(3)

3.3. Multilabel Classification Head

On top of the encoder, a linear multilabel prediction layer followed by a sigmoid activation is placed [36,37]. Given $z_i$ the logit vector $o_i\in {\mathbb{R}}^L$ and probability vector ${\widehat{y}}_i$ are as follows:

$$o_i=W{z}_i+b,{\widehat{y}}_i=\sigma \left(o_i\right)$$

(4)

where $W\in {\mathbb{R}}^{L\times d}$ and $b \in {\mathbb{R}}^L$ are trainable parameters, and σ($·$) is the element-wise sigmoid function.

To address label imbalance (rare but operationally important dependency types), a class-weighted binary cross-entropy loss is adopted [38,39,40]. Let ${\mathcal{W}}_{\mathcal{l}}>0$ be the weight for label $\mathcal{l}$, typically inversely related to its frequency. The supervised multilabel loss is

$${\mathcal{L}}_{\mathit{BCE}}=-\frac{1}{N}\sum _{i=1}^N\sum _{\mathcal{l}=1}^L{\mathcal{W}}_{\mathcal{l}}[y_{i\mathcal{l}}\mathit{log}{\widehat{y}}_{i\mathcal{l}}+(1-y_{i\mathcal{l}})\mathit{log}(1-{\widehat{y}}_{i\mathcal{l}})]$$

(5)

This term encourages accurate prediction of both common and rare dependency labels while compensating for the skewed distribution.

3.4. Meta-Contrastive Representation Learning

At the heart of our framework is a meta-contrastive optimization strategy, which sculpts the encoder fθ so that it learns embeddings, which are simultaneously discriminative for multilabel classification and robust to class imbalance [41,42,43].

3.4.1. Supervised Contrastive Loss

Bug reports are considered as points in a metric space, where “positive” pairs share at least one dependency label or belong to the same dependency center (meta-bug), while “negative” pairs have no overlapping labels [44]. For an anchor bug i, denote with $\mathcal{P}\left(i\right)$ the positive indices and with $\mathcal{N}\left(i\right)$ their negatives within a mini-batch. This study used a supervised InfoNCE-style contrastive loss [45]:

$${\mathcal{L}}_{\mathit{con}}=-\frac{1}{N}\sum _{i=1}^N\frac{1}{|\mathcal{P}(i)|}\sum _{j\in \mathcal{P}(i)}\mathit{log}\frac{\mathit{exp}(\mathit{sim}({\tilde{z}}_i,{\tilde{z}}_j)/\mathcal{T})}{{\sum }_{k\ne i}\mathit{exp}(\mathit{sim}({\tilde{z}}_i,{\tilde{z}}_j)/\mathcal{T})}$$

(6)

where $sim\left({\tilde{z}}_i,{\tilde{z}}_j\right)$ = ${\tilde{z}}_i^T{\tilde{z}}_j$ is the cosine similarity and $\mathcal{T}$ > 0 is a temperature parameter, since a temperature parameter allows the sharpness of the similarity distribution in the contrastive softmax to be adjusted. A smaller temperature reduces the effect of slightly similar positive pairs and tightens the separation to negative samples, so that the model can generalize a more discriminative dependency-aware embedding space.

This term explicitly attracts the semantically dependent bugs closer and repels independent ones further. It is a generalization to the multi-dependency case of the InfoNCE loss used in the work for bug–meta-bug pairs, in a supervised way.

3.4.2. Meta-Learning with Reptile-Style Updates

To enhance robustness, particularly under class imbalance and distributional shifts in the bug dependency types, contrastive learning is integrated with a Reptile-style meta-learning procedure [46,47], where a “task” is defined as a subset of sampled data batches reflecting different class distributions. Each “task” corresponds to a few labels, or centralities. For each meta-iteration:

(1)

Task sampling: a batch of tasks ${\left\{T_t\right\}}_{t=q}^M$ s sampled from the training data, where each task T_t contains its own support and query sets of bug reports.

(2)

Inner-loop adaptation: for task T_t, the model starts from the global parameters θ and performs K gradient update steps on the combined loss function [48].

$${\mathcal{L}}_{\mathit{inner}}^{\left(\mathit{t}\right)}={\mathcal{L}}_{\mathit{BCE}}^{\left(\mathit{t}\right)}+{\gimel }_{\mathit{con}}{\mathcal{L}}_{\mathit{con}}^{\left(\mathit{t}\right)}$$

(7)

obtaining adapted parameters θ_t.

(3)

Meta-update: aggregate the parameter updates across all sampled tasks and update the global encoder parameters using the meta-gradient [49].

$$\theta \leftarrow \theta +\alpha ·\frac{1}{M}\sum _{t=1}^M({\theta }_t-\theta )$$

(8)

where α is the meta-learning rate.

The Reptile optimization in our framework serves a purpose of finding an optimal model initialization that works well for both common and rare dependency types simultaneously. This approach addresses a critical challenge in multilabel bug dependency classification where certain dependency relationships occur far less frequently than others in Mozilla Firefox dataset. This differs from traditional domain transfer approaches because we focus on parameter initialization rather than adapting models across different domains. This operation is reminiscent of the Reptile meta-learning algorithm that performs multi-task adaptation through inner-loop process and averages parameter updates to arrive a meta-optimized initialization. In this implementation, the concept is adapted by employing a contrastive supervision inner loss function. This modification allows us to meta-train a final encoder that leverages its learned representations to fine-tune effectively on structures with varying dependency labelings.

It is important to note that, in the current experimental setting, meta-learning is employed to address within-project heterogeneity and extreme label imbalance rather than cross-project domain transfer.

3.5. Imbalance-Aware and Dependency-Aware Regularization

Besides class-weighted BCE, two additional regularization techniques are introduced to capture the multilabel dependency structure.

(a) Imbalance-aware penalty—For strongly asymmetric labels, we introduce a focal-style modulation term to re-weight learning on those difficult examples:

$${\mathcal{L}}_{\mathit{imb}}=-\frac{1}{N}\sum _{i=1}^N\sum _{\mathcal{l}=1}^L{\mathcal{W}}_{\mathcal{l}}{(1-{\widehat{y}}_{i\mathcal{l}})}^{\gamma }[y_{i\mathcal{l}}\mathit{log}{\widehat{y}}_{i\mathcal{l}}+(1-y_{i\mathcal{l}})\mathit{log}(1-{\widehat{y}}_{i\mathcal{l}})]$$

(9)

where $\gamma >0$ controls how strongly easy examples are down-weighted.

(b) Dependency-aware structural regularization—Let $C\in {\mathbb{R}}^{L\times L}$ be the label co-occurrence matrix estimated from training data, and L_c = D − C its graph Laplacian, where D is the diagonal degree matrix [50]. For a minibatch, let $F\in {\mathbb{R}}^{B\times L}$ contain the logits o_i as rows [50]. Labels that frequently co-occur are encouraged to exhibit similar logit patterns through the following formulation:

$${\mathsf{\Omega }}_{\mathit{dep}}=Tr\left(F{L}_{\mathit{c}}{F}^T\right)$$

(10)

This term discourages large dissimilarity between the outputs of strongly correlated label pairs, which is expected to help the learning of correlated dependencies and encourage the model to exploit the directed acyclic dependency structure around the meta-bugs reported in the dataset [50,51].

3.6. Overall Training Objective and Algorithm

During meta-training, the total loss for a task T_t combines the aforementioned components [52]:

$${\mathcal{L}}_{\mathit{total}}^{\left(\mathit{t}\right)}={\mathcal{L}}_{\mathit{BCE}}^{\left(\mathit{t}\right)}+{\gimel }_{\mathit{con}}{\mathcal{L}}_{\mathit{con}}^{\left(\mathit{t}\right)}+{\gimel }_{\mathit{imb}}{\mathcal{L}}_{\mathit{imb}}^{\left(\mathit{t}\right)}+{\gimel }_{\mathit{dep}}{\mathsf{\Omega }}_{\mathit{dep}}^{\left(\mathit{t}\right)}$$

(11)

where ${\gimel }_{con}$, ${\gimel }_{imb}$ and ${\gimel }_{dep}$ are hyperparameters controlling the contribution of each term.

The high-level training procedure is as follows [50,51,52]:

(1)

Initialize transformer encoder f_θ with pre-trained weights and randomly initialize classification head g_ϕ.

(2)

Repeat for meta-iterations:

• Sample a batch of tasks {T_t}.
• For each task, perform K inner-loop updates minimizing ${\mathcal{L}}_{total}^{\left(t\right)}$ on the support set to obtain ${\theta }_t$.
• Compute the meta-update $\theta \leftarrow \theta +\alpha ·{\displaystyle \frac{1}{M}}{\sum }_t\left({\theta }_t-\theta \right)$.
• Optionally, update ϕ jointly using gradients from the query losses.

(3)

After meta-training converges, fine-tune (θ, ϕ) on the full training set using ${\mathcal{L}}_{BCE}+{\gimel }_{dep}{\mathsf{\Omega }}_{dep}$ while keeping the contrastive term as an auxiliary regularizer.

This meta-contrastive regimen yields an encoder that is semantically informed by dependency relations, less sensitive to label imbalance, and well-suited for downstream multilabel prediction.

3.7. Inference and Decision Rule

At testing time, a new bug report x is processed as follows:

The same preprocessing and tokenization pipeline are consistently applied to all bug reports to ensure uniform input representation for model training [51,53].

(1)

It is to encode x with f_θ to obtain z and feed it into g_ϕ to compute $\widehat{y}\in {\left[0, 1\right]}^L$.

(2)

Next, it needs to convert probabilities into binary decisions using label-specific thresholds τ_ℓ tuned on a validation set:

$${\widehat{\mathrm{y}}}_{\mathrm{i}}^{\mathrm{bin}}=\{1,\mathrm{if}{\widehat{\mathrm{y}}}_{\mathrm{i}}\ge {\tau }_{\mathcal{l}}; 0,\mathrm{otherwise}\}$$

Label-specific decision thresholds τℓ were tuned on the validation split of each cross-validation fold by maximizing macro-F1 score. This strategy was consistently applied to all supervised models to ensure fair comparison. The unsupervised BM25 baseline follows the fixed threshold (0.5) adopted in prior studies.

(3)

Such multilabel vector informs which dependency types are predicted for the bug, thus offering finer-grained support in automatic dependency identification.

Through the fusion of transformer-based semantic representations, contrastive metric learning, meta-optimization and structure-aware regularization, the proposed framework precisely tackles the aforementioned challenges in multilabel bug dependency classification and is expected to significantly outperform unsupervised BM25-based baseline in terms of macro-F1 and rare-label performance.

4. Experimental Results

4.1. Baseline Models and Comparison Protocol

The efficacy of the proposed model is verified by comparing it with four baseline models that span a spectrum from unsupervised traditional methods to more advanced supervised and imbalance-aware learning approaches in fine-grained software dependency classification. All the baseline systems use the same textual inputs, including bug report’s summary and description fields. To ensure a fair evaluation, all models are trained and tested using the same 10-fold cross-validation setting mirroring the setup found in prior BM25-based work.

4.1.1. BM25-Based Unsupervised Dependency Assembly [8,54]

The baseline represents a traditional unsupervised rule-based approach to dependency detection. The method ranks pairs of bug reports based on BM25 lexical similarity and predicts dependency links when similarity exceeds a static threshold, typically 0.5 as established in previous studies. This approach does not depend on the labeled data and does not extract latent semantic structures. It performs dependency clustering using meta-bugs and serves as our lower-bound baseline, representing the type of non-semantic model commonly used in early automatic software maintenance research. It is as mentioned in previous works not robust to synonyms or paraphrases since it relies entirely on keyword overlap. Additionally, it cannot handle the multilabel nature of bug dependencies.

4.1.2. Transformer Encoder + Standard Weighted BCE Loss [18,55]

This baseline fine-tunes a BERT-base transformer encoder with a dense multilabel classification layer, training the system using class-weighted binary cross-entropy loss. While it uses contextual semantics through pre-trained transformer embeddings, it treats each dependency label independently and only focuses on minimizing classification error. The approach does not model relationships between different dependency types, which means it still suffers from the severe label imbalance problem common in real-world bug repositories where certain dependency types appear very infrequently.

4.1.3. Transformer + BCE with Focal Modulation [56,57]

To address the challenge of severe class imbalance, where minority dependency types have significantly fewer samples than majority classes, this baseline incorporates focal loss into the standard BCE objective. The focal loss mechanism down-weights well-predicted majority labels while directing more learning attention toward challenging and rare dependency types. Although this approach improves stability and recall for minority classes, it lacks an explicit mechanism for representing co-occurrence patterns among labels. This method also fails to leverage geometric re-parameterization scheme that could adjust embedding subspaces according to their dependency semantics.

4.1.4. Transformer + BCE + Dependency-Aware Laplacian Regularization [58]

This baseline incorporates structural knowledge through a label co-occurrence graph. A graph Laplacian regularizer is adopted to ensure that the classifier produces similar outputs for dependency types that frequently co-occur in real-world development workflows. This setting creates a dependency-aware inductive bias that gives the model partial knowledge about the semantic correlations among different relation types. However, this approach does not directly shape the semantic geometry of bug representations to capture relational similarity, nor does it employ meta-task adaptation strategies that could benefit rare label prediction.

4.2. Evaluation Metrics

As each bug report may contain multiple dependency types, the problem is formulated as a multilabel classification task. Hence, standard single-label based metrics like accuracy are not sufficient, especially because of the significant class imbalance where certain dependencies are much rarer than others. To model the global predictive behavior as well as the label-specific performance over class-imbalanced dependency distributions, three widely used multilabel evaluation metrics are employed [59]: micro-F1, macro-F1 and hamming loss. While other multilabel metrics exist, we prioritized these three metrics due to the specific characterizes of bug dependency data. We selected our evaluation metrics based on two key practical considerations that emerged during our analysis.

The first issue involves the limitations of Exact Match Ratio for dependency prediction. This metric is overly strict for this domain as in real world practice correctly identifying some dependencies is actionable for developers even if the full set is not perfectly predicted. A metric that assigns zero points for missing just one dependency fails to capture this practical utility and would misrepresent the model’s actual business value.

Second, given the extreme class imbalance in our dataset, ranking-based metrics such as Precision become unreliable in this context because the number of true dependencies varies dramatically across different bug reports.

Therefore, three complementary metrics were selected to capture different aspects of performance. Micro-F1 [59,60] considers the contributions of all dependency labels across all predictions and thus reflects performance on frequent and majority types of relations. The metric is particularly valuable for classifying bug dependencies, as most decisions arise from routine relationships such as “blocks” or “depends-on”. Thus, micro-F1 evaluates the capability of the model to accurately predict dependencies system wide.

Nevertheless, a high micro-F1 score may mask low recall on those rare but crucial dependency types, which are dominantly considered in real-world maintenance task (e.g., regression management and release scheduling). To account for this limitation, the macro-F1 score [59,60] is also reported, which averages the F1-score across labels and treats each dependency type as equally weighted regardless of its frequency. Thus, the macro-F1 score is a more discriminating and sensitive measure of success in recognition of low frequency but high-impact relationships that aligns directly with our research goal of improve rare dependency detection.

Finally, overall prediction reliability is measured using hamming loss to assess both false positives and false negatives in dependency assignments. Unlike the F1 scores, which focus only on positive cases, hamming loss [59,60] penalizes all incorrect labels decisions, thus providing a comprehensive view of how robust the model performs at the individual instance-label level.

While other multilabel evaluation metrics such as Exact Match Ratio, subset accuracy and ranking-based measures (e.g., Precision@k or AUC) are commonly used. However, they are less suitable for bug dependency prediction. Exact Match Ratio is overly strict and fails to reflect partial correctness, which is often sufficient for practical dependency management. Ranking-based metrics assume an ordered relevance structure, which is less meaningful when dependency labels are not inherently ranked. Therefore, micro-F1, macro-F1 and hamming loss were selected, as they provide a balanced and interpretable evaluation of overall accuracy, rare-label performance and error sensitivity under extreme class imbalance.

4.3. The Results

The proposed approach is compared against four established baselines that are commonly used in text-based bug dependency mining: BM25-based unsupervised clustering, transformer-based classifier with standard BCE loss, BCE combined with focal loss for imbalance awareness and BCE with dependency-aware Laplacian regularization. All models are trained and evaluated using a consistent 10-fold cross-validation scheme, as adopted in prior baseline studies, to ensure fair comparison.

4.3.1. Overall Performance Comparison

Performance is evaluated using micro-F1, macro-F1 and hamming loss across both global and multilabel levels.

Table 3. Comparative Performance Summary.

Method	Micro-F1	Macro-F1	Hamming Loss
BM25 Unsupervised (Baseline)	0.51	0.33	0.27
BERT + BCE	0.66	0.46	0.20
BERT + BCE + Focal	0.69	0.49	0.18
BERT + BCE + Dependency-Aware Reg	0.71	0.52	0.17
Proposed Method, called as MCOF	0.76	0.58	0.14

presents the overall performance comparison.

The experimental results in Table 3 demonstrate that our proposed MCOF achieves significant improvements over all baselines. These gains are consistent across a wide range of multilabel evaluation metrics. These observations confirm our underlying hypothesis that joint optimization of semantic representation and dependency-structured label learning is more effective in real-world bug dependency classification.

To assess the statistical significance of the observed performance differences, we conducted paired statistical testing across the 10 cross-validation folds. Specifically, a paired t-test was applied to compare the proposed method with each baseline in terms of macro-F1 and hamming loss. All reported improvements of MCOF over baseline methods were statistically significant at the 0.05 level.

Overall, the results from the BM25-based unsupervised baseline, especially the poor macro-F1 and comparatively high hamming loss, clearly indicate that lexical similarity alone is inadequate for capturing semantically grounded dependency semantics. Bug descriptions frequently use synonyms and paraphrasing, creating linguistic variations that keyword matching cannot handle. This further substantiates the need for semantic understanding for automatic dependency parsing.

By adopting supervised transformer models, an immediate performance improvement is observed. The BERT + BCE baseline leverages potential of deep contextual semantics with a considerable improvement in micro-F1 score of 15%, yet it barely provides help towards predictions of infrequent relationship types, resulting in mediocre performance gain on macro-F1. This confirms previous findings that standard multilabel objectives do not properly handle dominant label distributions in bug repositories.

The results with focal loss help confirm that being imbalance-aware matter. By personalized models more for missing rare cases, the BERT + BCE + Focal variant improves recall on minority labels, increasing the macro-F1 score by 0.03. Nevertheless, the marginal performance increase suggests that class imbalance is not the only issue. There are also structural correlations between labels that model needs to learn.

The dependency-aware regularization on baseline further narrows such a performance gap by imposing structural priors from the co-occurrence of dependencies. The improvements in all metrics, including a 0.05 boost in micro-F1 over the first transformer baseline, indicate that modeling relational topology is crucial for enhancing the classification of dependency types that coexist in real development workflows.

Lastly, comparing with all the baselines, the proposed MCOF achieves a remarkable overall best performance at both micro-F1 and macro-F1 metrics and reduces the hamming loss. These improvements demonstrate the effectiveness of meta-contrastive learning. Firstly, it organizes the latent embeddings into clusters that make relational sense. Secondly, it provides a transferable initialization that enhances the model generalization even when data is scarce. The rare dependency handles are the prime recipients of such semantic structuring and meta-adaptation, which is right in line with improving release readiness and regression management in software maintenance efforts.

In summary, MCOF performs consistently better than other methods on all the evaluation axes. This leads us to conclude that: (1) reliable deployment requires more than just semantic representations, it needs explicit modeling of dependency structures and (2) it is important to consider both label imbalance and shifts in task distribution. These findings indicate that the proposed approach constitutes a feasible and tangible contribution for reliable automated bug dependency classification in large industrial bug collections.

4.3.2. Label-Wise Results and Analysis

The sensitivity of the proposed approach under extreme class imbalance is investigated next by analyzing F1-scores for individual dependency classes. As shown in

Table 4. Label-wise F1-score comparison across dependency types.

Dependency Type	BM25	BERT	BERT + Focal	Proposed Method (MCOF)
Blocks	0.47	0.62	0.66	0.73
Depends-On	0.35	0.53	0.57	0.68
Related-To	0.21	0.38	0.41	0.52
Triaged-By-Meta-Bug	0.19	0.33	0.36	0.47

, the proposed meta-contrastive optimization framework (MCOF) achieves dramatically better performance than baseline methods on different dependency types. Most interestingly, the biggest improvements are observed for low-frequency dependency relations like ”Related-To” and “Triaged-By-Meta-Bug”. These categories usually have high uncertainty, low sample size, but are critical in real development workflows because they often represent things that should be escalated or release-blocking events. The superior performance of MCOF over these hard labels demonstrates its strong robustness to those and exemplifies the model’s ability to identify rare but critical dependency signals.

The label-wise results in Table 4 illustrate advantages of MCOF, but a more comprehensive explanation from critically interpretative point-of-views provides some valuable insights and future challenges worth noting.

First, although our model achieves the best F1-scores across all dependency groups, results are uneven across labels. For the “Blocks” relation, which is the most common label in our dataset with distinct lexical and semantic signals, it achieves a moderate improvement of about 7% over supervised baselines. This may indicate that, for well-represented relations, the baseline transformer models already capture most of the knowledge of the task, leaving less room for optimization.

In contrast, Related-To and Triaged-By-Meta-Bug, which have a higher level of complexity and lower support, demonstrate larger improvements. Such relations are often more semantic even though they transcended a “simple” textual overlap. The gains are actually uniformly around +11% across these labels. They do not arise only from helping the model learn better through meta-contrastive optimization; rather, they also indicate that, from another perspective, meta-contrastive does more than just powering up one single minority class: it empowers the entire model against un-sharpened, low-density data.

However, even with a big boost, the absolute F1 for rare labels (e.g., 0.47 for Triaged-By-Meta-Bug) is more moderate than high, which means that dependency detection is still inherently hard when textual descriptions are vague/ambiguous or do not have any explicit relational hint provided. This shows that meta-contrastive learning is capable of boosting discriminability; however, the semantic ambiguity in bug reports cannot be perfectly resolved.

Second, the results also suggest that label co-occurrence is still important in helping representation learning perform well, especially when little semantic evidence is available. The regularized dependency-aware mechanism guarantees performance enhancement by promoting the structure learning between labels. However, the constraints of functional dependency are sometimes informally stated in developers’ discussions, and the developers’ discussion was not included due to noise.

Finally, the fact that no results on very rare or long-tail dependencies (outside of these four “head” categories) were put forward here suggests a possible limitation in generalization as label distribution becomes more skewed. This implies that though MCOF already alleviates imbalance, further improvements may require more sophisticated strategies, such as hierarchical relational modeling and active learning, to achieve significantly better performance.

4.3.3. Additional Analyses for Explainability and Robustness

Error Analysis

To provide further insight into the remaining limitations of the model, two representative misclassification cases are additionally examined. The errors suggest that dependency cues in bug reports are often implicit or under-specified and problematic for text-based prediction. Especially, symptom-driven descriptions and relational context not being available sometimes lead to confusion about types of dependency or even make it impossible to identify any dependencies at all.

Table 5. Representative misclassification cases.

Bug Summary (Shortened)	True Label	Predicted	Root Cause of Error
“UI freeze after installing extension when switching tabs”	Depends-On	Blocks	Ambiguous cause-effect cues → model misinterprets as blocking issue
“Search field clears unexpectedly after form submit”	Related-To	None	Insufficient contextual information → no explicit relational hints

presents some representative examples of misclassification cases observed in the experiments.

The rest of the errors are largely due to the implicitness in dependency semantics within bug reports. The model also resorts to symptom keywords or makes no assignments when the relational evidence is uncertain/absent. This indicates that the better availability of contextual information (e.g., related bug IDs, comments or component meta-data) can help to improve real-world dependency classification.

Label-Wise Precision and Recall

To gain a deeper insight of how the proposed MCOF model performs across different types of dependencies, the performance metric is decomposed into precision and recall, enabling separation of errors arising from false-positive predictions (precision drop) and false-negative predictions (recall drop).

Table 6. Precision and recall per dependency type.

Label	Precision	Recall	Interpretation
Blocks	0.79	0.69	Strong lexical cues, well learned
Depends-On	0.75	0.65	Slight confusion with blocks
Related-To	0.59	0.46	Very broad meaning → semantic ambiguity
Triaged-By-Meta-Bug	0.52	0.43	Very sparse data + implicit dependency hints

tabulates the results for each label.

The findings presented in Table 3 show that model performance is strongest on blocks and Depends-On annotation sets, where the dependency clues are more easily expressed proudly (i.e., they are explicit). On the other hand, both Related-To and Triaged-By-Meta-Bug have lower recall and precision, suggesting that the model frequently cannot retrieve these rare and ambiguous relation types. These results are consistent with the practical challenge of recognizing implicit/under-specified dependencies in real-world bug reports, and further justify our optimization strategies to achieve performance improvement on minority labels.

Runtime and Complexity

We measure the computational overhead of MCOF towards its readiness for practical usage in CI/CD and DevOps pipelines through model inference. Comparison of the size of parameters and average inference time per bug report among BM25, transformer baseline, and our proposed MCOF model is presented in

Table 7. Runtime and complexity comparison.

Model	Number of Parameters	Avg. Inference Time per Sample	Notes
BM25	-	2.8 ms	Lexical search via ElasticSearch backend
Transformer + BCE	110	13 ms	Standard BERT fine-tuning baseline
Proposed Method (MCOF)	110	15 ms	+15% overhead for meta-contrastive + structure-aware steps

.

Despite incorporating meta-contrastive optimization and dependency-aware regularization, MCOF maintains a parameter size of approximately 110 M (standard BERT architecture). The added computational overhead is fairly small. Inference latency increases by less than 15% compared with the transformer + BCE baseline. In practice, the average inference time is approximately 15 ms. per bug report, which satisfies typical real-time requirements and allows over 60 reports to be processed per second on a single GPU.

However, because BM25 operates by lexical matching and it cannot fully exploit semantic relations. On the other hand, MCOF also obtains a significant gain on prediction accuracy while keeping low breakpoints. This validates that the improved classification performance is not at the expense of excessive computation.

In general, the runtime analysis results confirm that MCOF is not only more accurate but also production-ready for industrial software engineering scenarios, such as automated bug triaging pipelines, CI/CD workflows and continuous feedback systems.

4.3.4. Discussion: Strengths and Limitations of the Proposed Method

The primary contribution of this study lies in empirical evidence and systematic integration rather than algorithmic novelty, offering practical guidance for designing robust multilabel classifiers in software engineering domains.

The meta-contrastive optimization framework (MCOF) has shown promising results for addressing multilabel bug dependency classification problems in real software repositories. There are several advantages to this representation, with the most significant being the ability of it that integrates effective semantic representation learning via a transformer-based encoder that obtains in-depth contextual information rather than a simple lexical match. The incorporation of the meta-contrastive learning further boosts robustness ability, especially in unbalanced learning settings by better adjusting latent feature space to distinguish related buggy behavior from unrelated ones. Furthermore, the dependency-aware Laplacian regularization facilitates one a better appreciation of the co-occurring relations among bug types, resulting in significant performance gains on rare but high-rewarded labels on dependencies. In general, it outperforms unsupervised clustering and traditional supervised baselines in terms of both micro-F1 score and macro-F1 score while keeping its computational overheads sufficiently low for feasible inclusion within CI/CD pipelines.

Despite these positive attributes, however, there are several limitations to overcome. In the first place, the semantic cues for dependency relations are not explicitly expressed or indirectly mentioned in the textual reports. As this study only makes use of the summary and description fields, valuable contextual information present in developer discussions, linked issues or source code traces is not considered, which could lead to potential wrong predictions. Second, while MCOF enhances the recall of low-frequency labels, there is still moderate performance on rare dependency types overall, illustrating the inherent difficulty of our task under extreme longtail distribution. Third, the corpus used in this study is specific to one ecosystem (Mozilla Firefox), which may reduce the extent to which our findings generalize to other large-scale projects with differing documentation practices or bug dependency structures.

Remaining challenges indicate potential for future refinement by considering additional sources of multimodal data (e.g., comments, commit logs or stack traces), applying domain adaptation techniques to achieve robustness across project changes, and using active learning strategies to represent infrequent dependency cases more effectively. Nevertheless, the results of this work bring insight into how it is crucial to co-optimize semantics representations and dependency-aware structures—the fact that meaningful improvement can actually be made towards more robust and intelligent automated dependency analysis in software maintenance.

4.4. Ablation Study on Model Components

To disentangle the individual contributions of each component in MCOF, a systematic ablation study is conducted by removing one learning mechanism at a time while keeping the remaining components unchanged. This analysis allows the impact of meta-learning, supervised contrastive loss, imbalance-aware regularization, and dependency-aware Laplacian constraints on multilabel dependency classification performance to be quantified.

The ablation results in

Table 8. Ablation study on the proposed MCOF framework.

Variant	MCOF	Meta- Learning	Contrastive Loss	Imbalance-Aware Reg	Dependency-Aware Reg
Meta-Learning	✓	✗	✓	✓	✓
Contrastive Loss	✓	✓	✗	✓	✓
Imbalance-Aware Reg	✓	✓	✓	✗	✓
Dependency-Aware Reg	✓	✓	✓	✓	✗
Micro-F1	0.76	0.72	0.73	0.74	0.75
Macro-F1	0.58	0.51	0.53	0.54	0.55
Hamming Loss	0.14	0.17	0.16	0.16	0.16

reveal that the performance gains of MCOF stem from the complementary interaction of its constituent components rather than any single mechanism in isolation.

Removing the meta-learning module results in the largest degradation in macro-F1 (−0.07), particularly affecting rare dependency types, which confirms the importance of task-level adaptation for mitigating extreme label imbalance. This observation aligns with the long-tailed label distribution of the dataset, where conventional fine-tuning struggles to generalize to low-frequency dependencies.

Excluding the supervised contrastive objective leads to a noticeable drop in both macro-F1 and hamming loss, indicating reduced discriminative structure in the learned embedding space. This suggests that contrastive learning plays a critical role in organizing bug representations according to dependency semantics rather than surface-level lexical similarity.

In contrast, removing the imbalance-aware regularization primarily impacts macro-F1 while leaving micro-F1 relatively stable, confirming its targeted effect on minority labels. Finally, the absence of dependency-aware Laplacian regularization increases hamming loss, reflecting reduced consistency among correlated dependency labels.

Overall, these findings demonstrate that MCOF’s effectiveness arises from the synergistic integration of meta-learning, contrastive representation learning, and dependency-aware regularization, rather than reliance on any single optimization component.

4.5. Discussion: External Validity and Implications

4.5.1. Threats to External Validity

The most significant limitation of our work lies in testing MCOF exclusively on Mozilla Firefox bug reports. This single-project approach raises questions about whether our results would hold up in other software ecosystems. Projects like Apache or Chromium operate with distinct bug reporting cultures, terminology standards, and dependency classification approaches that could substantially impact model performance.

We recognize this limitation while noting several factors that help mitigate generalizability concerns. Our Mozilla dataset encompasses over ten years of development history and incorporates reports from thousands of contributors, which creates considerable internal diversity in writing styles and reporting practices. This variation within one ecosystem offers a meaningful assessment of how well the model handles different input patterns and communication approaches.

More importantly, MCOF does not depend on Mozilla-specific keywords or hardcoded rules that would tie it to this particular environment. The framework works with semantic representations that BERT extracts from natural language text. While terminology certainly varies between projects, similar problems tend to be described using similar language patterns, even when the exact words differ. The core strength of our approach lies in its targeted solution of using the combination of meta-learning and contrastive optimization to manage sparse, imbalanced datasets. This foundation suggests broad applicability across different bug tracking systems facing similar data skew.

Although we cannot make definitive claims about cross-project transferability without conducting additional experiments, the theoretical underpinnings of our method suggest strong potential for adaptation to other environments. Evaluating MCOF across diverse software repositories represents a crucial next step that would provide the empirical evidence necessary to establish the framework’s broader applicability. This validation work would strengthen confidence in deploying the approach across different organizational and technical contexts.

4.5.2. Implications for Practitioners

Managing bug dependencies remains a big issue for software developers. When developers file bug reports, it is not easy for them to see how the issue connects to existing problems. This incomplete picture leads to poor resource allocation decisions and release delays when critical dependencies are discovered too late in the development cycle.

MCOF, acting as an automated triage supporter, addresses this problem by analyzing bug reports at the moment they are submitted. Rather than waiting for developers to manually identify blocking relationships through trial and error, the framework can immediately flag potential dependencies based on the natural language description. This early warning system helps teams understand the true scope of a bug’s impact before committing development resources.

MCOF’s reliance on natural language descriptions makes it particularly valuable for real world deployment. This is because most bug tracking systems already collect this information as part of standard reporting procedures. Therefore, developer teams can integrate MCOF into their existing workflow without requiring additional metadata fields or changing how developers write bug reports. In practice, the system would function as an intelligent assistant that suggests possible dependencies for human review rather than making final decisions automatically as we value expertise of development teams.

4.5.3. Implications for Researchers

This work reveals important limitations in current approaches to multilabel classification problems in software engineering contexts. The common assumption that pre-trained language models can be directly fine-tuned for specialized technical applications be too optimistic, especially when dealing with highly skewed label distributions.

In our experiments, standard BERT fine-tuning performed poorly on rare dependency types, despite having access to the same textual information that enabled MCOF to succeed. This suggests that some software engineering tasks need more than general purpose language representations. They require learning strategies to handle class imbalance and limited training samples. Researchers should carefully examine whether their evaluation method adequately captures performance on minority classes that may be most crucial for practical applications.

The effectiveness of Laplacian regularization in our framework suggests that software artifacts exist within complex relational structures that traditional classification approaches ignore. Bugs, features and components are not independent entities but part of evolving systems where relationships matter as much as individual characteristics. This finding opens opportunities for researchers to explore how graph-based methods might improve performance across various software engineering prediction tasks.

5. Conclusions

In this study, we addressed the challenging problem of multilabel bug dependency classification, which represents a key activity in software maintenance and release planning workflow. Real-world bug repositories present several persistent challenges. First, highly skewed class distributions occur where certain dependency types dominate the dataset. Second, sparse annotation patterns leave many relationships unlabeled. Third, implicit dependency semantics are challenging to extract solely through text-based approaches.

To address these issues, we introduced the meta-contrastive optimization framework (MCOF), a systematic integration of meta-contrastive representation learning and dependency-aware Laplacian regularization layered onto a transformer-based classifier. This framework enhances discriminative capabilities in the embedding space while maintaining robustness under low-resource conditions and effectively capturing relational structures across diverse dependency types.

Our experiments on a real-world bug dependency dataset demonstrates that MCOF consistently outperforms established baselines, including the classical BM25-based clustering method and state-of-the-art transformer models. The framework archives performance gains, with improvements of +0.25 on both micro-F1and macro-F1 scores compare to the baselines, along with a successful reducing hamming loss. Furthermore, the results show the improvements for rare but critical dependency categories with absolute F1 scores increases reaching 16% minority classes. This indicates that MCOF effectively mitigates the bias towards majority labels. In addition, runtime and computational profiling were conducted to assess the practical impact of the additional optimization modules. The results demonstrate that these components introduce a marginal overhead, adding 15% to inference latency while ensuring acceptable efficiency levels. This performance profile makes MCOF suitable for integration within CI/CD pipeline(s) and automated bug triage systems. These findings support our conclusion that MCOF represents both theoretically grounded and practical viable solution for contemporary software engineering challenges.

Although the proposed approach performs well, some misclassification cases show that dependency cues in bug reports are sometimes under-specified or context-specific. To address this, our future work is to incorporate richer contextual data—e.g., discussion comments, commit logs and issue history—to build a deeper understanding of the semantics involved. Combining multimodal information and graph-based evolutionary representations of bug interactions can improve the detection of implicit relations, especially for those rare, long-tailed dependencies types. Furthermore, we intend to extend our evaluation to diverse software ecosystems, such as the Apache and Chromium repositories. This will allow us to assess the framework’s cross-project transferability and ensure it is generalising well beyond our current dataset. Finally. adapting the framework to dynamically update its dependency knowledge as new bug reports arrive would allow it to support continuous maintenance workflows in large-scale industrial environments.