eprints (HSR Hochschule für Technik Rapperswil)
Not a member yet
1196 research outputs found
Sort by
Event-Driven Architecture Lab
No full textEvent-Driven Architecture (EDA) is a software architecture paradigm that enables systems to process and react to events as they occur.
In this paradigm, an event is defined as any meaningful alteration in the state of a system.
The goal of applying EDA is to decouple components and systems; event producers do not need to know the event consumers. Scalability, flexibility, and maintainability are enhanced as software grows in size, scope, and complexity.
However, the decoupling comes at a price:
How to ensure reliability?
How to reconstruct the application state?
How to deal with increased variability?
The goal of this thesis was to construct a set of sample programs that explore selected EDA concepts, starting from a simple Publish-Subscribe System and eventually using the production-grade middleware Apache Kafka.
Four distinct sample programs were built, each of which is based on the preceding one.
Each program consists of a scenario revolving around a fictitious construction company, Skyline Construction Company (SCC).
SCC has experienced growth which places demands on its software systems.
Its main business application is a monolith written in Java that uses the Spring Boot framework.
To scale the existing system, the architects at SCC have decided to introduce EDA principles while maintaining operational continuity.
For each of these scenarios, we identified a feature and re-implemented it according to a EDA principles within the fictitious but realistic sample application.
A hybrid approach combining theory with practical implementation demonstrates how to integrate the abstract concepts of EDA into a Web-based monolithic backend application supported by a container framework.
The approach provides an accessible introduction to the subject while highlighting the trade-offs software architects and developers face when pursuing such an integration
Assessing RISC Zero using ZKit: An Extensible Testing and Benchmarking Suite for ZKP Frameworks
No full textZero-Knowledge Proofs (ZKPs) are cryptographic protocols designed to verify a statement without disclosing any information beyond its boolean verification outcome. A prevalent use case for such protocols resides in the realm of digital cash, where payers whish to prove the validity of a token without disclosing any specification about the token in particular to uphold privacy. Numerous ZKP software libraries or frameworks have emerged to enhance accessibility for developers and encouraging the widespread adoption of this technology in practical applications.
The thesis introduces the readership to ZKPs, elucidating their fundamental attributes and delving into two key implementation families — namely, Succinct Non-Interactive Argument of Knowledge (SNARK) and Scalable Transparent Argument of Knowledge (STARK) systems. Our emphasis is on the latter, given its perceived post-quantum security. Furthermore, we provide an overview of promising STARK-based ZKP frameworks and discuss their distinguishing features.
One of such frameworks is RISC Zero, which facilitates verifiable general-purpose computations in zero-knowledge through its virtual machine. Essentially, it proves statements indirectly by proving the integrity of all chronologically recorded register states throughout a computational process. We elucidate its internal mechanisms and assess its efficiency by examining two different disciplines. The first involves proving a preimage to a hash value. The second entails proving the membership of a data leaf within a Merkle tree, also known as inclusion proofs (IP).
To streamline systematic analysis, we present the concept of ZKit, an extensible test and benchmark suite designed to accommodate diverse ZKP frameworks. ZKit enables the orchestration of activities through a command line interface and incorporates a suggested information exchange format for IPs. Additionally, it demonstrates the process of porting ZKP functionality defined in the Rust programming language to Go.
We utilize ZKit to benchmark RISC Zero across various settings and workloads. Our results reveal that generating a single STARK proof for a batch of IPs can be up to 3.9 times more efficient than proving each IP individually. Verifying such batch proofs can even offer a performance improvement of up to 14 times. The thesis concludes by discussing key insights gained during the research process and summarizes the implications of the findings
Entwicklung einer gamifizierbaren Anwendung für die Programmierausbildung
No full textThis Bachelor's thesis documents the implementation and design of Codable. Codable is a user-centered application for creating, managing and solving exercises in an academic environment. Its main goal is to improve the organizational and qualitative problems of exercises in the Department of Computer Science, which were identified in the preceding semester thesis written by Lukas Messmer and Mathias Fischler. The paper focuses on the architectural design of Codable and documents aspects such as the implemented plugin system, the automation process for exercise submissions and evaluations, as well as the architectural decomposition of the system
AI-Powered Invoice Automation
No full textIntroduction and Goal: Etter Consulting Partners (ECP) processes invoices from hundreds
of energy and utility providers manually. The lack of standardization and the diversity of
formats make extracting data into a unified structure a time-consuming and error-prone task.
This project addresses these challenges by developing a prototype to automate the extraction
of detailed information from PDF invoices and convert it into a structured, machine-readable
format. The extracted data is formatted as JavaScript Object Notation (JSON), facilitating
seamless integration into subsequent analytical processes.
Methodology and Technologies: The prototype consists of a Python program that integrates
multiple technologies to tackle the complexities of invoice processing. Docling OCR plays a
crucial role in converting diverse PDF formats, including scanned invoices, into structured
Markdown, forming the foundation for data extraction. Large Language Models (LLMs) are
central to the process, identifying invoice providers and extracting key details from the text. QR
code recognition complements this by directly extracting provider information and relevant data
embedded within QR codes when available. Additionally, vector similarity search is employed
to identify the invoice provider by comparing document embeddings to known provider profiles.
Each component was optimized to address specific challenges. A dataset of manually parsed
invoices from ECP served as the benchmark for evaluating the pipeline’s accuracy and reliability.
Result: The project successfully achieved its primary objective of accurately parsing invoice
data and converting it into structured JSON. Both Claude Sonnet 3.5 and OpenAI GPT-4
demonstrated strong performance, with a best-case accuracy of up to 94% in specific cases, and
overall accuracies of 66.66% and 63.66%, respectively. Llama 3.3-70b reached an overall accuracy
of 60.68%. These accuracy metrics were determined using a custom scoring system developed
for this project and validated across a large dataset, confirming the software’s capability to
reliably automate data extraction. Challenges were identified in the categorization of line items,
where the LLM occasionally assigned incorrect categories due to limited contextual information.
Providing additional data for each possible category is expected to improve categorization
accuracy. Especially, the prompt plays a significant role in influencing results: with better
prompts, the system’s accuracy improves substantially. The project not only delivered a robust
prototype but also highlighted key areas for further refinement to enhance system scalability
and precision. Specifically, achieving more accurate categorization by augmenting the category
information and meticulously tuning each provider-specific prompt. The final solution is a
functioning Python CLI, supporting parsing through OpenAI GPT, Anthropic Claude, and
Llama, and can be used in any environment capable of executing Python
Hate Speech Detection with LLM
No full textThe increasing acceptance of hate expression, particularly through the internet and social media, has significantly amplified the presence of online hate speech. This phenomenon negatively impacts psychological health and can incite violence, necessitating effective detection methods to prevent such content from being posted or shared. A recent trend involves leveraging the large context windows of new Large Language Models (LLMs) to enable In-Context Learning (ICL) where correct examples showcased in the prompt window. Studies have demonstrated the ability of LLMs in hate speech detection using few-shot strategies, comparing their performance to fine-tuned models. However, bias is a prevalent issue in pre-trained LLMs, requiring identification and mitigation specific to the task or dataset.
In this study, an experiment is conducted on text-based hate speech detection using ICL for two LLMs (GPT-4.o mini and Llama 3.1 8B) alongside a fine-tuned BERT model, forming a voting ensemble. The objective of this study is to assess whether bagging with majority voting can balance the strengths and weaknesses of individual models, thereby mitigating specific biases and achieving fairer, more accurate categorization of hate speech, offensive language and normal language.
The study results demonstrate that, while all LLMs exhibit different biases toward various labels (e.g., normal language being marked as offensive), majority voting effectively reduces bias and improves accuracy in categories where the participating models were close in performance. However, in scenarios where the performance of the participating models varies drastically, for example in the category offensive in this study, majority voting does not outperform the best single model. Furthermore, the voting ensemble encountered cases where a draw occurred, comprising about 5.4% of the total 13’229 data entries. Separate considerations were made for these ambiguous cases - either excluding them from the evaluation or replacing them with the best model’s decision. Excluding ambiguous data entries helped improve accuracy and reduce bias in misclassification but did not fully achieve the task's purpose of reaching a comprehensive result. This study underscores the potential of ensemble approaches in enhancing the fairness and accuracy of hate speech detection systems
Unit Testing of Analytic Rules for Microsoft XDR
No full textMicrosoft’s SIEM solution for Azure cloud environments is Sentinel. Sentinel allows
for “analytics rules” to be created, which are used to search for patterns and
indicators in the SIEM data. Creating these analytics rules can either be done in the
Sentinel GUI which can be tedious, or via synchronization with a Git repository.
When using the latter option, the analytics rules come in the form of JSON
formatted ARM templates. These templates define the analytics rule as code, just like
any other deployment as code in the Azure cloud. Unfortunately, this comes with the
downside that a deployment is not tested in any way before it is deployed.
This thesis presents the implementation of an automated Azure DevOps pipeline to
validate Sentinel analytics rules to some extent before deployment, mitigating the risk
of errors of deployments greatly and introducing continuous testing into the process.
The solution also abstracts the complexity of the ARM template structure, which can
be hard to read, by accepting YAML rules as input which mainly focus on the most
crucial content of the rule itself, without having to care about metadata.
To achieve this, the following tools have been integrated:
• Maester as an automated testing framework.
• SentinelARConverter which converts YAML rules into ARM templates.
• ARM Template Test Toolkit to test for syntactical and to some extent semantic correctness of the finalized ARM template.
• KQL Analyzer to test the syntactical correctness of the KQL query provided with the rule (Kusto Query Language)
Keywords: Microsoft Sentinel, Azure DevOps, Automated Testing, ARM
Templates, KQL Validation, Maester Framewor
Network Configuration Automation with Infrahub and Nornir
No full textAbstract:
This document outlines the design and implementation of an automated system for VLAN management as part of the project “Network Configuration Automation with Infrahub and Nornir”. The solution leverages Infrahub as a single source of truth, providing a unified platform for managing network infrastructure data. Nornir, a Python-based automation framework, handles configuration deployment with dry-run validation to detect potential misconfigurations:
- Infrahub serves as the central repository for network infrastructure data, providing version control and collaboration through GitLab.
- Python Transformers: convert Infrahub data into a Pydantic model representing YANG models.
- NETCONF XML Exporter generates valid NETCONF payloads.
- Nornir automates the deployment of NETCONF configurations, offering flexibility and scalability.
- Conditional Runner enforces concurrency limits and controlled task execution, enhancing automation stability.
Key Features:
- Dry-Run Validation: Identifies misconfigurations preemptively.
- Reconciliation Mechanism: Detects configuration drifts for remediation.
- Centralized Management: Streamlines oversight of network configurations.
Benefits:
Automating VLAN configuration reduces human intervention, minimizes errors, and enhances network reliability. Validation and centralized management improve efficiency, reliability, and scalability.
Conclusion:
The “Network Configuration Automation with Infrahub and Nornir” project automates VLAN management by enforcing validation and centralizing oversight, modernizing network management for greater efficiency and scalability
Integration of Deep Computer Vision Foundation Models for Document Analysis
No full textIntegration of Deep Computer Vision Foundation Models for Document Analysis:
Enhancing Optical Character Recognition Using an OCR-free Transformer Model
This study explores the efficacy of a pre-trained transformer model from the open source Hugging Face Library applied in the domain of Optical Character Recognition (OCR), specifically to the task of extraction of dates from scanned documents.
Initially, OCR technology concentrated on recognizing patterns, using algorithms based on specific rules, to identify letters and numbers through their distinct shapes. Deep learning greatly improved accuracy and the ability to work with more nuanced text and complex layouts, which in combination with Large Language Models (LLMs) has made visual document understanding possible.
Approach: The conventional OCR approach follows two steps: First, one would OCR a scanned document with the help of an OCR engine like Tesseract, and then process the output using pattern matching and regular expressions, or, alternatively, a LLM trained for the specific field of application. A major limitation of OCR engines, however, lies in their generic nature, which often brings challenges in accuracy and efficiency.
The OCR-free or pseudo-OCR approach instead relies on a single encoder-decoder transformer model which integrates the aforementioned two steps, making it an end-to-end solution which can be adjusted and fine-tuned for a specific field of application.
For this project I selected the OCR-free Document Understanding Transformer model (Donut) which was initially pre-trained on an extensive and varied collection of documents. I then fine-tuned it on a targeted datasets of diverse sizes to find out model’s ability to read, understand and extract dates from images. I evaluated the results based on accuracy and the model's adaptability to different document types and qualities, as well as different date formats.
Conclusion: The results of the study are encouraging, achieving an average accuracy of 75% on the somewhat limited training and test datasets meticulously assembled for fine-tuning. The OCR-free approach undoubtedly shows promise in performing atomic tasks on images such as extracting dates. However, its efficacy could be significantly enhanced by incorporating a wider variety of document types and date formats. Additionally, adapting it to manage scenarios with zero, one, or multiple dates in a single image is likely necessary. Data engineering has emerged as a crucial element, even in this proof-of-concept stage
Digital Forensics - Creation of a Crime Scene and Digital Evidences
No full textDigital forensics is a rapidly developing field that is critical to modern law enforcement, cybersecurity, and legal investigations.
It is crucial to have well-educated professionals to ensure that criminal activity in the digital realm can be correctly and securely identified.
The work presented in this paper serves to advance the field of digital forensics by combining a comprehensive theoretical foundation with the creation of a practical learning environment.
Thorough documentation of the creation of this investigation lab not only supports educational efforts by providing instructional materials, but also aims to serve as a stepping stone for future similar endeavours.
Creating digital evidence can be time-consuming, and it requires a high degree of attention to detail.
The methods evaluated in the presented work can support the creation of future labs to strengthen the forensic community.
The theoretical foundation examines fundamental concepts in digital forensics, focusing on the dynamic nature of cyber threats, evolving technologies, and the legal landscape.
Emphasis is placed on the significance of a proactive and adaptive approach to investigations, taking into account the challenges posed by encrypted communications, cloud storage, and emerging technologies.
By showing the development process of a forensic training scenario using a concrete example, readers are introduced to both challenges and opportunities faced when creating similar work
What’s up in RJ
No full textThis project is about creating a simple-to-use web application that centralizes a list of events and organizers in the vicinity of Rapperswil-Jona. Its purpose is to present all kinds of fun, interesting and exciting events to the regional residents.
The application is built from scratch, there is no existing platform used as a base. With a centralized platform it is possible for organizers to easily publish their own events. Anyone can sign up as an organizer, making it appealing to all people and organizations looking to advertise their events. Users of the platform benefit from this by being able to find events advertised by regional, national, and even global organizers. After creating a user account, they can simply subscribe to the newsletter, delivered twice a month, informing them about new and upcoming events that match their preferences.
The approach is to create a web application consisting of a frontend, backend, and database layer. Deployed with a cloud hosting provider, the application is widely accessible to all users. Following the initial inception phase, the application underwent design and development during the elaboration phase. The implementation of the entire application was then done during the construction phase. Additionally, various tests were conducted, including usability tests with real end users to evaluate the user experience.
This first iteration is a good starting point to create a seamless platform where users and organizers are able to interact with each other. In future steps, it is recommended to implement additional features to increase the application's appeal. This project has considerable potential to become a successful platform for event organizers and attendees