FG Praktische Informatik / Softwaresystemtechnik
Refine
Year of publication
Document Type
Way of publication
- Open Access (9)
Keywords
- Softwaretechnik (10)
- Konfigurationsmanagement (4)
- Produktlinien (4)
- software evolution (4)
- Applications (2)
- Capture (2)
- Clustering (2)
- Design Rationale (2)
- Research Proposal (2)
- Softwaremetriken (2)
Institute
Recent research on intelligent healthcare employs Deep Reinforcement Learning (DRL) to personalize treatments according to patients’ physiological characteristics and thus render treatments more effective. However, the majority of approaches rely on the relational data model, that struggles with the representation of the complex relationships within medical data. Moreover, the output of these approaches is typically a recommended action, e.g., a dosage; however, clinicians need the contextualization, i.e., the provision of supporting information, of such recommendations in order to decide whether to follow it.We present a neuro-symbolic architecture for personalized treatments based on a graph-centric foundation. The architecture is based on representing medical data as a knowledge graph and learning via graph neural networks; their combination enables the inherent capturing of relationships and their native integration into reasoning, which may thus render recommendations more effective. Moreover, the architecture employs formally specified graph queries over the knowledge graph to contextualize personalized treatments. We exemplify the architecture by an application to sepsis treatments and based on a widely-used medical dataset.
Sepsis is a serious, life-threatening condition. When treating sepsis, it is challenging to determine the correct amount of intravenous fluids and vasopressors for a given patient. While automated reinforcement learning (RL)-based methods have been used to support these decisions with promising results, previous studies have relied on relational data. Given the complexity of modern healthcare data, representing data as a graph may provide a more natural and effective approach. This study models patient data from the well-known MIMIC-III dataset as a heterogeneous graph that evolves over time. Subsequently, we explore two Graph Neural Network architectures - GraphSAGE and GATv2 - for learning patient state representations, adopting the approach of decoupling representation learning from policy learning. The encoders are trained to produce latent state representations, jointly with decoders that predict the next patient state. These representations are then used for policy learning with the dBCQ algorithm. The results of our experimental evaluation confirm the potential of a graph-based approach, while highlighting the complexity of representation learning in this domain.
The optimization of business processes is an important task to increase the efficiency of the described workflows. Metaheuristic optimization, such as evolutionary search, has been used to optimize business process models, but it requires a high level of expertise that not all process designers have. Model-driven optimization (MDO) promises to make the use of metaheuristic optimization accessible to domain experts without in-depth technical expertise by allowing them to specify the optimization algorithm directly at the model level. Because this approach is less technical, the process designers can focus on the business process models and their properties. Using concrete business process optimization problems as a starting point, we discuss how MDO can be applied to these problems, what MDO would offer for business process optimization, and how the application to business processes could stimulate research on MDO.
We study nested conditions, a generalization of first-order logic to a categorical setting, and provide a tableau-based (semi-decision) procedure for checking (un)satisfiability and finite model generation. This generalizes earlier results on graph conditions. Furthermore we introduce a notion of witnesses, allowing the detection of infinite models in some cases. To ensure completeness, paths in a tableau must be fair, where fairness requires that all parts of a condition are processed eventually. Since the correctness arguments are non-trivial, we rely on coinductive proof methods and up-to techniques that structure the arguments. We distinguish between two types of categories: categories where all sections are isomorphisms, allowing for a simpler tableau calculus that includes finite model generation; in categories where this requirement does not hold, model generation does not work, but we still obtain a sound and complete calculus.
In model-driven engineering, runtime monitoring of systems with complex dynamic structures is typically performed via a runtime model capturing a snapshot of the system state: the model is represented as a graph and properties of interest as graph queries which are evaluated over the model online. For temporal properties, history-aware runtime models encode a trace of timestamped snapshots, which is monitored via temporal graph queries. In this case, the query evaluation needs to consider that a trace may be incomplete, thus future changes to the model may affect current answers. So far there is no formal foundation for query-based monitoring over runtime models encoding incomplete traces.
In this paper, we present a systematic and formal treatment of incomplete traces. First, we introduce a new definite semantics for a first-order temporal graph logic which only returns answers if no future change to the model will affect them. Then, we adjust the query evaluation semantics of a querying approach we previously presented, which is based on this logic, to the definite semantics of the logic. Lastly, we enable the approach to keep to its efficient query evaluation technique, while returning (the more costly) definite answers.
Graph APIs are capable of flexibly retrieving or manipulating graph-structured data over the web. This rather novel type of APIs presents new challenges when it comes to properly securing the APIs against the usual web application security risks, e.g., broken access control. A prominent security testing approach is taint analysis, which traces tainted, i.e., security-relevant, data from sources (where tainted data is inserted) to sinks (where the use of tainted data may lead to a security risk), over the information flow in an application.
We present a first systematic approach to static and dynamic taint analysis for Graph APIs focusing on broken access control. The approach comprises the following. We taint nodes in the Graph API if they represent data requiring specific privileges in order to be retrieved or manipulated, and identify API calls which are related to sources and sinks. Then, we statically analyze whether tainted information flow between API source and sink calls occurs. To this end, we model the API calls using graph transformation rules. We subsequently use critical pair analysis to automatically analyze potential dependencies between rules representing source calls and rules representing sink calls. The static taint analysis (i) identifies flows that need to be further reviewed, since tainted nodes may be created by an API call and used or manipulated by another API call later without having the necessary privileges, and (ii) can be used to systematically design dynamic security tests for broken access control. The dynamic taint analysis checks if potential broken access control risks detected during the static taint analysis really occur. We apply the approach to a part of the GitHub GraphQL API.
On an exemplar supporting model-based quality assurance research for healthcare systems-of-systems
(2024)
As healthcare is being massively digitized, it increasingly relies on the harmonious interaction of autonomous and interconnected software systems. In this context, it becomes crucial to ensure that the emergent behavior that occurs when these systems interact remains beneficial to the overall quality goals. This task requires that the interacting systems are conceptualized and further studied as a System-of-Systems (SoS). We present the design and prototypical implementation of an exemplar for such a Healthcare SoS (HSoS) which consists of different types of basic healthcare systems. Its typical quality goals, e.g., safety and interoperability, and selected technical characteristics, e.g., cloud-nativity and support for integration with robotics, render the exemplar representative of modern healthcare solutions. The exemplar simulates patient journeys which rely on the interaction of the constituent systems and thereby may capture the emergent behavior of the HSoS. Our aim is that the exemplar supports future research on quality assurance for HSoSs using model-based techniques, which are suitable for developing both SoSs and safety-critical systems. For each quality goal, we outline relevant challenges as well as our research plans.
In model-driven engineering, the adaptation of large software systems with dynamic structure is enabled by architectural runtime models. Such a model represents an abstract state of the system as a graph of interacting components. Every relevant change in the system is mirrored in the model and triggers an evaluation of model queries, which search the model for structural patterns that should be adapted. This thesis focuses on a type of runtime models where the expressiveness of the model and model queries is extended to capture past changes and their timing. These history-aware models and temporal queries enable more informed decision-making during adaptation, as they support the formulation of requirements on the evolution of the pattern that should be adapted. However, evaluating temporal queries during adaptation poses significant challenges. First, it implies the capability to specify and evaluate requirements on the structure, as well as the ordering and timing in which structural changes occur. Then, query answers have to reflect that the history-aware model represents the architecture of a system whose execution may be ongoing, and thus answers may depend on future changes. Finally, query evaluation needs to be adequately fast and memory-efficient despite the increasing size of the history---especially for models that are altered by numerous, rapid changes.
The thesis presents a query language and a querying approach for the specification and evaluation of temporal queries. These contributions aim to cope with the challenges of evaluating temporal queries at runtime, a prerequisite for history-aware architectural monitoring and adaptation which has not been systematically treated by prior model-based solutions. The distinguishing features of our contributions are: the specification of queries based on a temporal logic which encodes structural patterns as graphs; the provision of formally precise query answers which account for timing constraints and ongoing executions; the incremental evaluation which avoids the re-computation of query answers after each change; and the option to discard history that is no longer relevant to queries. The query evaluation searches the model for occurrences of a pattern whose evolution satisfies a temporal logic formula. Therefore, besides model-driven engineering, another related research community is runtime verification. The approach differs from prior logic-based runtime verification solutions by supporting the representation and querying of structure via graphs and graph queries, respectively, which is more efficient for queries with complex patterns. We present a prototypical implementation of the approach and measure its speed and memory consumption in monitoring and adaptation scenarios from two application domains, with executions of an increasing size. We assess scalability by a comparison to the state-of-the-art from both related research communities. The implementation yields promising results, which pave the way for sophisticated history-aware self-adaptation solutions and indicate that the approach constitutes a highly effective technique for runtime monitoring on an architectural level.…
Graphs are used as a universal data structure in various domains. Sets of graphs (and likewise graph morphisms) can be specified using, e.g., the graph logic Image 1 of Graph Conditions (GCs). The evaluation of a graph against such a GC results in a Boolean satisfaction judgement on whether the graph is specified by the GC. The graph logic Image 1 is known to be as expressive as first-order logic on graphs. However, since infinitely many graphs exist, there are also infinitely many evaluations for each given GC. To support GC validation, testing, debugging, and repair, a suitable synthesis procedure generating a complete compact overview of how a given GC may be evaluated for possibly varying graphs is called for.
In a previous paper, we generated such an overview for a given GC in the form of a complete finite set of diverse evaluations for varying associated graphs formally given by so called Evaluation Trees (ETs). Each of these ETs concretely describes how its associated graph is evaluated against the given GC by recording the executed evaluation steps. Moreover, these generated ETs and the given GC for which they are generated have the same underlying structure easing comprehensibility of the represented evaluation steps. The returned ETs are complete since each possible ET subsumes one of the returned ETs and diverse by not containing superfluous ETs subsuming smaller ETs.
We now extend and refine this approach still solving the ET synthesis problem by (a) extending the graph logic GL allowing for the specification of a minimal number of graph patterns to be contained in specified graphs, (b) provide means to scale the size of the generated ETs up to a user-provided bound allowing for the generation of not just minimal ETs, (c) record the order of evaluations steps also for operators where the evaluation but not the operator itself defines such an order, and (d) generate ETs recording combinations of reasons for (non-)satisfaction of GCs where only single reasons were recorded before.
