Textual data used to train large language models (LLMs) exhibits multifaceted bias manifestations, encompassing harmful language and skewed demographic distributions. Regulations such as the EU AI Act require identifying and mitigating biases against protected groups in data, with the ultimate goal of preventing unfair model outputs. However, practical guidance and operationalization are lacking. We propose a comprehensive data bias detection and mitigation pipeline comprising four components that address two data bias types, namely representation bias and (explicit) stereotypes for a configurable sensitive attribute. First, we leverage LLM-generated word lists, created according to defined quality criteria, to detect relevant group labels. Second, representation bias is quantified using the Demographic Representation Score. Third, we detect and mitigate stereotypes using sociolinguistically informed filtering. Finally, we mitigate representation bias through Grammar- and Context-Aware Counterfactual Data Augmentation. We conduct a twofold evaluation using gender, religion , and age as examples. First, we evaluate the effectiveness of each individual component on data debiasing through human validation and baseline comparison. The findings demonstrate that we successfully reduce representation bias and (explicit) stereotypes in a text dataset. Second, we evaluate the effect of data debiasing on model bias by benchmarking several models (0.6B-8B parameters) fine-tuned on the debiased text dataset. This evaluation reveals that LLMs fine-tuned on debiased data do not consistently show improved performance on bias benchmarks. These results expose critical gaps in current evaluation methodologies and highlight the need for targeted data interventions to address manifested model bias.

The increasing need for simulation-based analysis along the life-cycle of modern process plants introduces new requirements and limitations in the development of simulation models. In the context of modular plants, according to VDI 2776, the distributed knowledge arises as a challenge in enabling system simulations. Co-simulation can enable a provider-independent simulation of chemical processes, but the co-simulation interfaces need further standardization to be efficiently integrated in the modular plant life-cycle. This paper works toward the usability of process models for co-simulation to support standardization efforts and make simulation models more usable and re-usable. To increase the usability of co-simulation in the process industry by working towards a common standard, two co-simulation standards, namely the Functional Mock-Up Interface and the CAPE-OPEN standard, are semantically linked. A use-case for a co-simulation-based operability analysis of a heterogeneous electrolysis plant is presented and necessary model requirements and interfaces are defined. Criteria to assess the compatibility of the model interfaces as a first step of a usability analysis are collected and presented. With the available requirements and interface specifications Functional Mock-Up Units can be created and the shown use-case can be carried out. Challenges regarding the potential integration of varying thermophysical properties have been pointed out and methods to overcome these challenges in the context of usability have been outlined.

In this paper we compare different operation strategies for alkaline electrolyzis (AEL) systems using numeric simulation. We derived general models for mass and energy balances from literature and composed them into a model for an AEL system. Here we considered a numbered-up plant topology, containing multiple AEL stacks with single electrolyte distribution and gas separation systems. The gas impurities and achievable minimal load distribution were compared for the different operating strategies. The results were discussed and further conclusions for the operation of a homogeneous numbered-up AEL system were derived.

We present ScrutinAI, a Visual Analytics tool to leverage semantic understanding for deep neural network (DNN) prediction analysis, focusing on models for object detection and semantic segmentation. Typical fields of application for such models, e.g., autonomous driving or healthcare, have a high demand for uncovering and mitigating data- and model-inherent shortcomings. Our approach helps analysts and/or auditors use their semantic understanding to identify and investigate potential weaknesses in DNN models. ScrutinAI includes interactive visualizations of the model’s inputs and outputs, interactive plots with linked brushing, data filtering with textual queries on descriptive meta data and an interactive similarity based image retrieval feature. The different views and data filtering options enable global and local inspection of DNN predictions. Overall, the tool fosters hypothesis driven knowledge generation which aids in understanding the model’s inner reasoning. Insights gained during the analysis process mitigate the “black-box character” of the DNN and thus support model improvement and the generation of a safety argumentation for AI applications. We present two case studies on the investigation of DNN models for pedestrian detection from the automotive domain.

Distributed (or federated) training of neural networks is an important approach to reduce the training time significantly. Previous experiments on communication efficient distributed learning have shown that model averaging, even if provably correct only in case of convex loss functions, is also working for the training of neural networks in some cases, however restricted to simple examples with relatively small standard data sets. In this paper, we investigate to what extent distributed communication efficient learning scales to huge data sets and complex, deep neural networks. We show how to integrate communication efficient distributed learning into the big data environment Spark and apply it to a complex real-world scenario, namely image segmentation on a large automotive data set (A2D2). We present evidence based results that the distributed approach scales successfully with increasing number of computing nodes in the case of fully convolutional networks.

In this demo, we present FERARI, a prototype that enables real-time Complex Event Processing (CEP) for large volume event data streams over distributed topologies. Our prototype constitutes, to our knowledge, the first complete, multi-cloud based end-to-end CEP solution incorporating: a) a user-friendly, web-based query authoring tool, (b) a powerful CEP engine implemented on top of a streaming cloud platform, (c) a CEP optimizer that chooses the best query execution plan with respect to low latency and/or reduced inter-cloud communication burden, and (d) a query analytics dashboard encompassing graph and map visualization tools to provide a holistic picture with respect to the detected complex events to final stakeholders. As a proof-of-concept, we apply FERARI to enable mobile fraud detection over real, properly anonymized, telecommunication data from T-Hrvatski Telekom network in Croatia.

The organization and planning of services (e.g. shopping facilities, infrastructure) requires quantitative information about the number of customers and their frequency of visiting. In this paper we present a framework which enables the collection of quantitative visit information for arbitrary sets of locations in a distributed and privacy-preserving way. While trajectory analysis is typically performed on a central database requiring the transmission of sensitive personal movement information, the main principle of our approach is the local processing of movement data. Only aggregated statistics are transmitted anonymously to a central coordinator, which generates the global statistics. In this paper we present our approach including the methodical background that enables distributed data processing as well as the architecture of the framework.

Events that happened in the past are important for understanding the ongoing processes, predicting future developments, and making informed decisions. Important and/or interesting events tend to attract many people. Some people leave traces of their attendance in the form of computer-processable data, such as records in the databases of mobile phone operators or photos on photo sharing web sites. We developed a suite of visual analytics methods for reconstructing past events from these activity traces. Our tools combine geocomputations, interactive geovisualizations, and statistical methods to enable integrated analysis of the spatial, temporal, and thematic components of the data, including numeric attributes and texts.We also support interactive investigation of the sensitivity of the analysis results to the parameters used in the computations. For this purpose, statistical summaries of computation results obtained with different combinations of parameter values are visualized in a way facilitating comparisons. We demonstrate the utility of our approach on two large real data sets, mobile phone calls in Milano during 9 days and flickr photos made on British Isles during 5 years.

In the context of the European SCY project, a collaborative, learner-centric TEL environment is described. Reference workflows and workflow executions are analyzed to extract meaningful behavioural attributes automatically. The extracted patterns provide insights into learner behaviour.

An important task in exploration of data about phenomena and processes that develop over time is detection of significant changes that happened to the studied phenomenon. Our research is focused on supporting detection of significant changes, called events, in multiple time series of numeric values. We developed a suite of visual analytics techniques that combines interactive visualizations on time-aware displays and maps with statistical event detection methods implemented in R. We demonstrate the utility of our approach using two large data sets.

Mobile robot applications operating in wireless environments require fast detection of link failures in order to enable fast repair. In previous work, we have shown that cross-layer failure detection can reduce failure detection latency significantly. In particular, we monitor the behavior of the WLAN MAC layer to predict failures on the link layer. In this paper, we investigate data mining techniques to determine which parameters, i.e., the events, or combination and timing of events, occurring on the MAC layer most probably lead to link failures. Our results show, that the parameters revealed with the data mining approach produce similar or even more accurate failure predictions than achieved so far.

The integration of small mobile systems and devices into existing computing infrastructures requires efforts on the programming and on the networking layer. Both layers are often addressed by middleware that offers simple abstractions at the programming layer while implementing them on the networking layer. This paper focuses on JavaSpaces and Jini, a middleware provided by Sun. JavaSpaces implement a shared tuple space, a popular abstraction at the programming layer. Jini supports JavaSpaces on the networking layer. Unfortunately, Jini requires a full Java virtual machine and does not run on small systems. This paper presents an alternative implementation of the JavaSpace abstractions that is independent of Jini. It allows integrating transparently small devices into existing infrastructures while using the usual JavaSpace abstractions. Design, implementation and results are presented.

Traditionally, real-time requirements are expressed by means of deadlines, which are imposed by the environment on the system. This approach, however, is not well suited for expressing real-time requirements on the interaction between objects; such as found in distributed systems supporting autonomy of objects. This paper presents a coherent framework in which real-time requirements for such interacting objects can be expressed. Two interrelated system layers are considered together: the communication layer and the distributed programming layer that describes how interactions between the objects are organized. In particular, the paper evaluates the relationship between real-time requirements and real-time activities in distributed object-oriented systems

There is a general trend in designing distributed control systems to give an increasing amount of autonomy to the individual nodes of such systems. Autonomous nodes interact only loosely. But also, close cooperation under hard real-time constraints is required in certain situations. This paper analyzes approaches for structuring distributed control systems and presents an architecture integrating object-oriented frameworks, publisher/subscriber communication, and hard- and soft-real-time communication. For supporting mobile robots. Wireless communication is considered in particular.

Autonomous systems are expected to provide increasingly complex and safety-critical services that will, sooner or later, require the cooperation of several autonomous systems for their fulfillment. In particular, coordinating the access to shared physical and information technological resources will become a general problem. Scheduling these resources is subject to strong real-time and reliability requirements. In this paper, we present an architecture that allows autonomous mobile systems to schedule shared resources in real-time using their own wireless distributed infrastructure. In our architecture, there is a clear separation between the application-specific scheduling part that is modeled as a function of the global state and the communication part that is used to provide the global state. By isolating the more error-prone communication part within a communication hardcore, the reliability of the overall system is increased and the locally executed scheduling function can be designed with primary focus on the application-specific real-time requirements.

High-precision clock synchronization is one of the most basic requirements in distributed real-time systems. This paper presents an enhanced clock synchronization protocol for wireless local area networks based on the IEEE 802.11 standard. Reducing the time-critical path of the protocol enhances the synchronization precision. As wireless communication links are inherently unreliable, special emphasis is put on fault tolerance. The protocol guarantees high precision even in the presence of message losses. The protocol is implemented in a Windows NT NDIS driver for Lucent WaveLAN cards. For this driver-level implementation, our measurements have shown that a precision of 150 /spl mu/s is achieved.

Object-oriented frameworks have become a key element in the design of distribution systems. They make the existence of the physical and operating system level resources transparent to the designer and provide the abstract view of the distributed systems as a set of objects that interact by invoking well-defined interfaces of each other. Easy reuse of existing components, location transparency and implementation hiding are the main ingredients of such frameworks that simplify the task of designing distributed systems drastically. It is desirable to take advantage of these benefits when designing distributed real-time systems, too. However, this goal conflicts with the essential need to consider the allocation of system resources when real-time requirements must be met. Here, system level resource issues such as execution times on CPUs, thread switches, occurrence of interrupts, and message delays are of primary interest. Our approach to solve this dilemma is to allow and support the designer of distributed real-time object-oriented applications to become aware of system level resources. We present a monitoring tool JewelDC that allows monitoring of distribution activities (i.e. nested sequences of object invocations) in a distributed object-oriented framework. Distributed activities are visualized at the abstract object level while simultaneously revealing their use of system level resources. The tool has been implemented for DCOM on Microsoft Windows NT 4.0.

Continuous clock synchronization avoids unpredictable instantaneous corrections of clock values. This is usually achieved by spreading the clock correction over the synchronization interval. In the context of wireless real time applications, a protocol achieving continuous clock synchronization must tolerate message losses and should have a low overhead in terms of the number of messages. The paper presents a clock synchronization protocol for continuous clock synchronization in wireless real time applications. It extends the IEEE 802.11 standard for wireless local area networks. It provides continuous clock synchronization, improves the precision by exploiting the tightness of the communication medium, and tolerates message losses. Continuous clock synchronization is achieved with an advanced algorithm adjusting the clock rates. We present the design of the protocol, its mathematical analysis, and measurements of a driver level implementation of the protocol on Windows NT.

Designing control and robotic systems as autonomous decentralized systems introduces a new degree of flexibility in the manufacturing and in the application of such systems. This flexibility is required for the systems to work in environments that are not totally predictable and that can change dynamically. In this paper, we present a new concept for real-time communication that supports this flexibility while still preserving real-time guarantees for hard real-time communication. The concept is designed to work on multiple-access busses. In particular we consider its application on wireless local area networks and field-busses. The concept addresses requirements of hard-real time, soft real-time and non real-time communication. For this, we extend the TDMA (time-division multiple-access) approach for time-triggered hard-real time communication by the concept of shared channels that support event-triggered communication and coexist with hard real-time channels. A first implementation of concept has been carried out in the context of the CAN-bus.

Designing distributed real-time systems as being composed of communicating objects offers many advantages with respect to modularity and extensibility of these systems. However, distributed real-time applications exhibit communication patterns that significantly differ from the traditional object invocation style. The publisher/subscriber model for inter-object communication matches well with these patterns. Any implementation of that model must address the problems of binding subscribers to publishers, of routing and filtering of messages, as well as reliability, efficiency and latency of message delivery. In the context of real-time applications, all these issues must be subject to a rigid inspection with respect to meeting real-time requirements. We argue that for embedded control systems built around smart microcontroller-powered devices these requirements can only be met when exploiting the properties of the underlying network. The CAN-Bus (CAN: Controller Area Network) which is an emerging standard in the field of real-time embedded systems is particularly suited to implement a publisher/subscriber model of communication. We present an implementation of the real-time publisher/subscriber model that exploits the underlying facilities of the CAN-Bus. In particular, we introduce a novel addressing scheme for publisher/subscriber communication that makes efficient use of the CAN-Bus addressing method. We provide a detailed design and implementation details along with some preliminary performance estimations.

Real time computing is becoming an enabling technology for many important distributed applications such as flexible manufacturing, multimedia, robotics and process control. Traditionally, real time systems have been realized as isolated embedded systems. Unfortunately, this approach no longer suffices for future complex systems in the application scenarios mentioned above. In this situation, the use of an object oriented design paradigm greatly reduces the complexity of the system while improving reusability and manageability. Furthermore, the surrounding IT infrastructure is more and more accessible through object oriented interfaces (e.g. CORBA). In addition, object oriented modeling allows reflection of the dynamic characteristics of the applications mentioned above by instantiating objects dynamically. In order to meet the real time requirements in such an environment, static scheduling is not sufficient since many non predictable resource conflicts influence execution times. Therefore, the most distinguishing requirement of these complex heterogeneous systems is the need of the computing system to dynamically adapt to dynamically changing conditions. Little work has been done on integrating object oriented system design with resource allocation algorithms that are flexible enough to cope with this new requirement. The paper presents an approach for an adaptive object oriented system with integrated monitoring, dynamic execution time prediction and scheduling. It explains how this approach is applied to CORBA and C++.

Atomic transactions are now a familiar paradigm for distributed programming and have been provided in a number of object-oriented languages. Much effort has also been expended on developing open transaction processing systems which support distributed transactions involving multi-vendor database systems. This paper addresses a number of issues that arise in combining object-oriented distributed programming with open transaction processing. We describe an approach to supporting transactions which can access objects and other resource types, such as files and records, consistently, and which is independent of the use of any particular object-oriented programming language. We discuss both the design of a generic run-time interface which provides language independent support for atomic objects and transactions and, following the X/Open model for open transaction processing, the design of an interface between the transaction manager and a resource manager which is suitable for the requirements of object-oriented systems. We illustrate our approach by describing the transaction sub-system of the Amadeus/RelaX implementation of the Comandos platform which supports a number of popular object-oriented languages and has been integrated with an existing relational database system.

The authors provide a description of RelaX (reliable distributed applications support on UniX), a portable and extensible system software layer on top of UNIX-like operating system kernels that supports reliable distributed applications by a generalized transaction mechanism. The transaction mechanism relieves each programmer of dealing explicitly with error recovery and concurrency control in every distributed application. In order to make transactions applicable as a general programming tool, flexibility has been introduced into the traditional transaction concept. The transaction mechanism is isolated in a server (Transaction Manager) that cooperates with an extensible set of resource managers, which provide different kinds of long-term storage entities accessible by RelaX transactions. Each resource manager provides a standard interface to the transaction kernel, and, if so desired, additional resource managers can be built. In order to ease the construction of new resource managers, RelaX provides generic software components as building blocks for any kind of resource manager. The RelaX architecture is described and the design of an examplary resource manager, the transactional object management system which provides access to persistent shared objects, is outlined.>

Transactions are especially valuable in distributed systems, since they isolate the programmer from the effects of both concurrency and failures. In implementing transactions at the system level, flexibility has to be introduced into the transaction concept. Specifically, the premature release of data objects has to be addressed. To assure recoverability, resulting dependencies between transactions are stored by the system in a distributed data structure called a recovery graph. The storing of redundant information in the recovery graphs at the different sites reduces the complexity of the commit protocol, and a chase protocol used to abort transactions can be derived which excludes infinite chasing. The redundant information can be distributed almost for free because it can be piggybacked on messages. The new commit/abort protocols will be used in the RelaX project (reliable distributed applications support on Unix), which carries on work done at GMD in the PROFEMO project on distributed transaction mechanisms.>