LLMORPH: Automated Metamorphic Testing of Large Language Models

1. Problem Statement

The rapid adoption of Large Language Models (LLMs) in Natural Language Processing (NLP) has highlighted critical reliability issues, including bias and hallucinations. However, automated testing of LLMs faces a significant "Oracle Problem."

• The Challenge: While generating test inputs for NLP is easy due to the abundance of text data, verifying the correctness of the model's output is difficult without human-annotated ground truth labels.
• The Bottleneck: Traditional testing relies on expensive, time-consuming human-labeled datasets to act as "oracles" (judges of correctness). This limits the scale of testing and hinders the ability to detect faults in specific, edge-case scenarios.
• The Gap: Although Metamorphic Testing (MT) is a known technique for addressing the oracle problem in general software, its application to LLMs remains understudied and lacks comprehensive tooling.

2. Methodology: Metamorphic Testing (MT)

The paper proposes LLMORPH, an automated testing tool that leverages Metamorphic Testing to bypass the need for labeled data.

• Core Concept: Instead of checking if a single output is correct, MT verifies the relationship between outputs of related inputs.
• Metamorphic Relations (MRs): An MR defines how the output should change (or remain consistent) when the input is transformed in a specific way.
  • Example: If two input texts are paraphrases, their outputs should be semantically similar. If an input has random spaces added, the output should remain unchanged.
• Workflow:
  1. Source Input: A raw text input is selected.
  2. Transformation: The input is transformed into a "follow-up" input based on a specific MR (e.g., paraphrasing, adding noise, changing case).
  3. Execution: The LLM is queried with both the source and follow-up inputs using the same task prompt.
  4. Comparison: The outputs are compared against the expected relationship defined by the MR.
  5. Result: If the relationship is violated, a fault is detected, even without knowing the "ground truth" answer.

3. Key Contributions: The LLMORPH Tool

LLMORPH is a modular, open-source Python tool designed to automate this process for researchers and developers.

• Architecture & Extensibility:

  • Inputs: Accepts unlabelled text data, specific NLP tasks (via prompts), and a selection of MRs.
  • Tasks: Currently supports four built-in tasks: Context-based Question Answering (QA), Natural Language Inference (NLI), Sentiment Analysis (SA), and Relation Extraction (RE). Users can easily add new tasks via JSON configuration files.
  • MR Implementation: Implements 36 unique Metamorphic Relations derived from a systematic literature review of 1,024 papers (identifying 191 total MRs).
  • Transformation Mechanisms:
    • Function-based: Simple transformations (e.g., adding spaces) use standard libraries (nlpaug).
    • LLM-based: Complex transformations (e.g., paraphrasing) use a secondary "transformation LLM" with few-shot prompting.
  • Comparison Mechanisms:
    • Syntactic: Direct string equivalence or set comparison.
    • Semantic: Uses BERT-based models (PARAPHRASE-MINILM-L6-V2) with cosine similarity thresholds (default 0.8 for equivalence, 0.4 for difference).

• Usability:

  • Supports both Command Line Interface (CLI) and configuration file execution.
  • Designed to work with various LLMs via APIs (currently OpenAI) or local deployments.
  • Includes checkpointing to handle large-scale runs and resume capabilities.

4. Evaluation Results

The authors conducted a large-scale evaluation to validate LLMORPH's effectiveness.

• Scale:
  • Models Tested: GPT-4, LLAMA3, and HERMES 2.
  • Datasets: SQUAD2, SNLI, SST2, and RE-DOCRED.
  • Volume: 561,267 test executions across 36 MRs.
• Findings:
  • Fault Detection: LLMORPH successfully exposed faulty behaviors with an average failure rate of 18%.
  • Complementarity: The tool detected bugs that traditional benchmark-based testing (relying on labeled data) missed, proving it is a complementary approach.
  • False Positives: Manual analysis of 937 violations revealed false positive rates ranging from 0% to 70%, depending on the specific MR and task. This aligns with known limitations of MT in NLP but is considered acceptable given the scale of automated detection.
  • Efficiency: Evaluation is fast, primarily dependent on the latency of 2–3 LLM calls per source input.

5. Significance and Future Work

• Significance:
  • Democratizes Testing: By removing the dependency on expensive labeled data, LLMORPH enables scalable, automated robustness testing for any LLM.
  • Community Resource: It provides the first comprehensive catalog and tooling for applying MT to LLMs, bridging the gap between theoretical MRs and practical implementation.
  • Modularity: The tool's design encourages community contribution to expand the library of MRs and NLP tasks.
• Future Directions:
  • Expanding the implementation from the current 36 MRs to cover more of the 191 identified relations.
  • Supporting a wider variety of NLP tasks and local LLM deployments.
  • Refining the reduction of false positives through better semantic comparison techniques.

Conclusion: LLMORPH represents a significant step forward in Software Engineering for AI (SE4AI), offering a practical, scalable solution to the oracle problem in LLM testing and enabling the detection of subtle, context-dependent failures that traditional benchmarks often overlook.