Model-Aware Data Curation

• Model-aware data curation is a framework that systematically extracts, annotates, and refines diverse data and code to align with specific computational model requirements.
• It employs a hybrid architecture combining knowledge-driven reasoning with data-driven extraction, semantic graph construction, and automated code translation to optimize model reusability.
• Empirical evaluations show high precision and recall in method extraction and conversion, while highlighting challenges in parsing complex equations and inconsistent code practices.

Model-aware data curation refers to the set of computational and methodological strategies for extracting, organizing, annotating, and refining datasets or scientific models such that the curated output is precisely tailored for downstream computational modeling and analysis. Distinct from generic or passive curation, model-aware curation is explicitly sensitive to the requirements, structure, and idioms of the target model or analytic framework. The following sections provide a detailed overview of concepts, system architectures, methodologies, applications, performance characteristics, and future directions, grounded in the technical advances described in the literature (Mulwad et al., 2022).

1. Hybrid Architecture for Model-Aware Extraction and Annotation

The system described in (Mulwad et al., 2022) is built around a dual-modality pipeline with two interlinked modules—Code2Triples for source code artifacts and Text2Triples for textual descriptions and equations. Extraction proceeds along two orthogonal axes:

• Knowledge-driven reasoning leverages a Code Extraction Meta-model (CEM), defining ontological classes such as CodeBlock, Method, and CodeVariable, along with inference rules (implemented with Jena). This module parses code (using JavaParser to obtain Abstract Syntax Trees), infers implicit model properties (e.g., the first reference to a variable is treated as an implicit input), and encodes artifacts and their relationships into a semantic knowledge graph.
• Data-driven extraction employs a BiLSTM-CRF slot-filling model (with Flair, stacking GloVe and character-level embeddings) to recognize and extract scientific entities and equations from surrounding textual information (inline comments, documentation).
• Ontology alignment and deduplication occur via string similarity and external resource matching (notably with Wikidata), using UIMA ConceptMapper for concept extraction and Elasticsearch to retrieve canonical URIs and units.

This architecture is consciously model-aware: it tailors annotation and extraction toward the representation needs of computational models (e.g., distinguishing executable method signatures, tracking input/output variables, and mapping domain terminology to standardized concepts).

2. Semantic Knowledge Graph Construction and Reasoning

Extracted information is formalized as a domain-specific knowledge graph (KG). The process comprises:

• Encoding code-derived entities: Each method, its argument types, variables, and results are represented following the CEM ontology. Implicit semantic relationships and types are inferred using rule-based reasoning.
• Formally linking text-extracted concepts: Scientific concepts, quantities (with units), and equations are annotated using domain ontologies. Classes such as ScientificConcept and UnittedQuantity denote variables and their semantic properties, while Equation and ExternalEquation formalize in-text and externally defined models, respectively.
• Alignment with external resources enhances semantic interoperability. Scientific variables are associated with canonical Wikidata entities, bringing standardized units and properties.
• Integration of code and text extractions produces a graph that combines computational interfaces with scientific context, directly supporting downstream composition and analysis.

The model-aware KG structure enables not only accurate semantic retrieval but also the dynamic assembly and re-use of computational models, facilitating interpretability and modularity in later applications.

3. Executable Model Conversion and Compositional Workflows

Curation proceeds beyond semantic annotation to executable implementation:

• Code translation: Java methods, once extracted and semantically classified, are mechanically translated to Python using a modified java2python pipeline, preserving model logic and type information.
• Equation parsing and conversion: Textual equations undergo a rule-based, character-level parsing to identify computational dependencies. The parser recursively resolves operator precedence (e.g., exponentials), converts bracketed sub-expressions, and aligns function names (such as “exp”) to Python calls. Both left- and right-hand sides are strongly typed, and input/output identification is performed during parsing.
• Composable Python functions: Each model or equation produces an independent Python function. Functions can then be linked (e.g., in diagnostic or prognostic pipelines) using semantic metadata from the KG, enabling flexible workflow construction.
• Human-assisted interface: An extended controlled-English interface (SADL) supports human-in-the-loop curation of the KG, enabling domain experts to query, validate, and refine model representations.

The conversion logic is depicted in algorithmic pseudocode:

def text_to_python(equation_string): output = "" for char in equation_string: if char.isalnum(): output += char elif char in operators: # handle precedence and expression grouping process_operator(output, char) handle_brackets_and_functions(output) return output_as_python_function

This pipeline allows automated, model-consistent translation of legacy code and scientific documentation into reusable computational artifacts.

4. Experimental Evaluation: Performance and Coverage

The approach was benchmarked using complex source material from NASA’s Hypersonic Aerodynamics website:

• Code2Triples successfully extracted all 132 computational methods envisioned across eight software applets, even under sparse documentation.
• Text2Triples processed 63 web pages, achieving mean precision 0.89 and recall 0.92 for equation extraction.
• The text-to-Python module translated 276 valid equation strings into 374 candidate Python methods; 77.7% were judged correct by domain experts.
• Nearly half of documentation pages yielded over 90% correctness in auto-generated methods.
• The resultant KG supports sophisticated downstream reasoning: e.g., enabling automated simulation and prognosis of aerodynamic conditions.

These results provide empirical evidence that leveraging automated, model-aware curation can yield both high recall and high precision in semantic model extraction for complex scientific domains.

5. Limitations and Technical Challenges

• Source code characteristics pose significant obstacles: sparse commenting, tangled computational and GUI logic, and evolving or inconsistent identifier schemes restrict extraction of augmented types and limit semantic inference.
• Language and granularity support: The current system is Java-centric and focuses extraction only at method-level granularity, excluding more fine-grained code blocks or hybrid codebases.
• Parsing limitations: Textual equation handling struggles with advanced mathematical constructs (particularly exponentiation patterns like “e^-(1 + γ)”) and ambiguous notational conventions, sometimes requiring manual correction.
• Ontology coverage and evolution: Dynamic scientific domains can outpace available ontologies or introduce terms with ambiguous semantics not present in Wikidata.

The necessity to resolve these issues motivates ongoing work on expanding language coverage, integrating finer-grained code analysis, migrating more stages to data-driven extraction, and strengthening interactive, expert-driven refinement.

6. Outlook and Future Research

Next steps for model-aware curation systems of this form include:

• Granular extraction and language generalization: Supporting statement- and block-level curation and integrating more source and scripting languages (e.g., C++, Fortran, Python).
• Fully data-driven semantic typing: Transitioning from rule-based to representation-learning-based augmented type extraction for robustness across scientific domains.
• Advanced equation parsing: Developing syntax trees and probabilistic parsing strategies for broader mathematical language coverage.
• Feedback and continuous learning integration: Enhancing interfaces so that expert feedback and model discovery dynamically update both the KG and the extraction models themselves, establishing a true interactive, model-aware curation cycle.

7. Significance and Broader Impact

Integrating model-aware data curation transforms heterogeneous, code-plus-text scientific artifacts into actionable, interoperable, and executable models. By uniting code parsing, NER, ontology-driven typing, automated code synthesis, and expert-guided curation, these systems deliver robust semantic interoperability, facilitate workflow composition, and accelerate scientific understanding and model repurposing. The application of such frameworks in fields like hypersonic aerodynamics demonstrates their potential for substantial impact in data-driven modeling, simulation, and decision-support across scientific and engineering disciplines.