Eye tracking is a key enabling technology for wearable and extended-reality devices, but conventional frame-based systems struggle to capture the eye's rapid motion within the tight compute and power budgets of such hardware. Event cameras, which report per-pixel brightness changes asynchronously at microsecond resolution, are a natural fit for this setting, yet most event-based methods rely on heavy neural networks that are impractical to deploy on resource-constrained devices. This thesis presents a lightweight, training-free pipeline for near-eye gaze estimation that maps the tracked pupil to a point of gaze on the screen. The pupil is first detected in gray-scale frames using a purely geometric procedure of thresholding, morphological filtering, and ellipse fitting, and its center is then propagated between frames directly on the event stream by a points-to-edge template tracker, providing high-frequency updates without reconstructing an image. The pupil observation is mapped to gaze using a polynomial regressor. Evaluated on two near-eye datasets, the geometric detector matches a model-based baseline and approaches a supervised segmentation network, while the full system runs end-to-end in under a millisecond on a CPU - several orders of magnitude cheaper than learned alternatives. The work trades some gaze accuracy for the ability to run without a GPU or training data, at the cost of a small number of per-subject detection thresholds, offering a practical path toward efficient, deployable event-based eye tracking. ... Read more

Large Language Models (LLMs) are increasingly deployed in high-stakes applications, where unreliable outputs can have serious consequences. However, quantifying their uncertainty and providing verifiable guarantees on their predictions remains an open challenge. We investigated the use of conformal prediction (CP), a statistical framework for generating prediction sets with provable coverage guarantees, to address this gap in LLM-based fact-checking. Using Llama-3.1-8B-Instruct and Mistral-7B-Instruct-v0.3, we evaluated three non-conformity scores on more than 10,000 claims verified by PolitiFact, spanning statements made between the website's launch in 2007 and January 2026. By formulating PolitiFact verdict classification as a multiple-choice question answering (MCQA) problem, we assessed the LLMs' confidence in classifying claims into PolitiFact's six "Truth-O-Meter" veracity ratings. We found that access to the corresponding fact-check article sharply reduced prediction set sizes, yielding sets small enough to be useful to a human fact-checker. Without this evidence, prediction sets typically contained both true and false labels, indicating that the models could not reliably distinguish true from false claims on their own at the 90% marginal coverage level. In this way, this research advances the application of LLMs in high-stakes contexts requiring verifiable bounds on error rates. ... Read more

Visual objects can appear in many different forms due to changes in recording conditions, including position, orientation, scale, viewpoint, and other spatial effects. Although these changes alter the image, they often do not alter the object category. In practice, robustness to geometric variation is usually obtained either by augmenting the training data with transformed examples or by introducing learned transformation modules. This makes the current models use huge data which limits their use to privileged few. This raises a fundamental question: do recognition models learn geometric transformations as reusable geometric structure, or do they learn transformed versions of specific object classes? Our experiments indicate that a significant portion of a model's learning capacity is consumed by memorizing how each category appears across the range of applied transformations. To investigate this question, we perform controlled experiments on synthetic datasets like MNIST and Fashion-MNIST. First, we quantify how much additional training data required when geometric transformations are present to reach a comparable accuracy. Second, we test whether transformation knowledge learned from one object class transfers to another. To compliment our findings on synthetic datasets we extend our results to a real world dataset namely German Traffic Sign Recognition Benchmark (GTSRB). Our results suggest that robustness to geometric transformations should not be treated as something that standard models will reliably learn from data alone. Instead, future work should focus on developing models that learn geometric transformations as reusable operations allowing current vision models to train efficiently and reduce the dependence on large amounts of training data. ... Read more

Odour-cued memory retrieval has emerged as a potential intervention for people with dementia due to the unique properties of odour-evoked memories. The design and application of technologies that integrate this strategy require knowing which odours are meaningful to a given person, motivating the systematic modelling of odour-event associations across the lifespan. In this paper, we introduce a computational pipeline that uses a Large Language Model (LLM) to simulate diverse persona profiles and model these associations at scale. We constructed persona-event pairs by operationalising age, gender, nationality, origin environment, and personal values. Then we prompted the LLM to generate an odour description and its most likely source for each pair. A bottom-up open card sorting taxonomy is then applied to cluster the odour sources into 13 odour types, forming an exploratory olfactory memory map, while events are also clustered similarly into 33 event types. Empirical analyses confirm the significance of systematic odour-event associations being encoded in our LLM-generated sample. While interaction effects for lifespan were not significant, the total effects for events, lifespan and cultural indicators were significant. The interaction effects of our cultural indicators were also significant for our sample. This study is a step towards using LLMs as a computational proxy in the field of LLMs for personalised assistive technologies to be adaptive and culturally inclusive in order to aid patients with dementia. ... Read more

The Tiny Machine Learning (TinyML) brings deep learning to Microcontroller Units (MCUs), but the few hundred kilobytes of Static Random-Access Memory (SRAM) available on these devices make deployment difficult. While model weights can reside in Flash, the intermediate activations generated at inference must fit in SRAM. For the efficient Convolutional Neural Networks (CNNs) that dominate TinyML, such as MobileNetV2, MCUNet, MnasNet, and Proxy lessNAS, it is the peak activation footprint rather than the model size that limits deployment. These networks are built from Inverted Residual Blocks (IRBs), whose expand–depthwise–project structure produces a large temporary activa tion inside each block that can exceed the SRAM of a single MCU. Distributing CNNs across several networked MCUs can aggregate their memory, but existing distributed runtimes communicate at layer or sub-layer boundaries. This turns the expanded activation inside each IRB into a network-level object that must traverse the network twice and be buffered in full at the coordinating device, creating both a communication and a memory bottleneck.

This thesis presents a framework that transforms a standard CNN into a communication-efficient distributed execution across a cluster of networked MCUs. An offline stage quantizes the model to an 8-bit integer and compiles it into a communication-aware execution plan and per-worker manifests. An online stage executes the plan on a coordinator–worker cluster. There are two novel mechanisms in the system: block-wise local execution, which keeps each expanded activation inside a worker, and cross-block data reuse, which exchanges only the thin boundary rows between consecutive blocks.

We implement the framework on a network of six MCUs and evaluate it on four representative IRB-based CNNs. Compared with naive layer-wise execution, our framework reduces early-block communication overhead by over 80%, end-to-end inference latency by up to 47%, and coordinator peak SRAM from 735 KB to 158 KB. ... Read more

As software systems evolve, refactoring becomes essential for preserving maintainability, yet identifying suitable refactoring opportunities remains difficult. Existing automated refactoring tools often depend on static rules or explicit developer requests, limiting their ability to account for broader code and process context. This thesis investigates how automated refactoring support can move towards a proactive, developer-facing workflow by combining metric-based prediction with large language model reasoning.

The proposed pipeline uses stacked prediction models to detect candidate Java refactoring opportunities and then applies large language model-based components to assess, select, and generate patches for plausible operations. The workflow was implemented in an IntelliJ IDEA plugin. The system was evaluated on 2,000 real-world Java examples created after the training cutoff of the evaluated models, using Qwen2.5-Coder models of 7B, 14B, and 32B parameters. In addition, 12 developers evaluated the plugin in a 2x2 crossover study.

The results show that large language models can improve metric-based refactoring prediction mainly as selective filters, reducing false positives and supporting reviewable suggestions. However, this filtering introduces a precision-recall trade-off, and candidate reranking still remains an open problem. The 14B model produced the strongest candidate lists for developer review, while the 32B model was more selective and the 7B model was faster but less stable.

This thesis shows that large language models can improve automated refactoring support when used in a human-in-the-loop IDE workflow. The strongest use case being reviewable, developer-controlled assistance. Future work should address broader refactoring coverage, multi-label prediction, better datasets, and edit-history-based techniques for faster in-IDE suggestions. ... Read more

Autonomous coding agents such as Claude Code and Codex are now used broadly to write code across entire repositories. They rely on large language models (LLMs), which are known to be sensitive to small behavior-preserving changes in their input. Renaming a variable or reordering code can reduce the accuracy of a standalone model, even though the program's functionality remains the same. It is not clear whether agents have this same weakness, since they can explore the codebase, run tests, and correct any issues through a feedback loop.

This work studies the robustness of coding agents to metamorphic transformations applied across the repository. We use three behavior-preserving transformations that rename identifiers, restructure control flow, and reorder methods. We transform 25 instances from the SWE-rebench-V2 dataset and run Claude Code and Codex on both the original and transformed versions.

The results show that coding agents appear more robust than standalone LLMs. Still, both agents tend to explore the codebase more in the transformed version. For Claude Code, we see an increase in the success rate, while Codex shows greater run-to-run variability in the input tokens, making it less predictable. We read these trends as evidence that the agents are relying less on memorized patterns and more on freshly-read code. Still, this tendency toward robustness should be considered a practical observation, not definitive proof. The run-to-run variance of the agents is large, often larger than the effect we look for, so we can only show we don't see a difference, but cannot prove there is none. So, to answer the question in our title: in practice, most likely robust. ... Read more

Legal contract review requires practitioners to find specific provisions
in documents that can span hundreds of pages, and errors in this task
carry direct legal consequences.
Standard retrieve-and-extract pipelines reduce hallucination by grounding
language model outputs in retrieved document text, but their single
retrieval step cannot follow cross-references, check whether the gathered
evidence is complete, or reliably confirm that a clause is absent.
Whether having a language model actively direct each retrieval step,
rather than passively reading a fixed set of retrieved chunks, improves
clause extraction accuracy has not, to the best of our knowledge,
been tested.
This thesis provides a controlled comparison of retrieve-and-extract
and LLM-orchestrated iterative retrieval on the Contract Understanding
Atticus Dataset (CUAD), keeping all components except the retrieval
architecture constant and evaluating both systems across all 38 clause
categories under Exact Match, token-level F1, and ROUGE-L.
Iterative retrieval consistently outperforms single-pass retrieval.
The main experiment, a 5427-pair run on Gemma4~e4b, a 4-billion-parameter
model run locally via Ollama, improves Exact Match from 0.687 to 0.744, Token
F1 from 0.341 to 0.505, and ROUGE-L from 0.308 to 0.467, with every gain
statistically significant under paired tests.
A smaller balanced run on both models confirms this and shows the gain again on
the larger closed model GPT-5-mini, which improves from Exact Match 0.711 to
0.800, Token F1 0.314 to 0.538, and ROUGE-L 0.283 to 0.490.
The F1 gains substantially exceed the Exact Match gains in every case,
indicating that iterative retrieval improves the completeness of
extracted clause text, not only presence-or-absence decisions.
The comparison isolates the contribution of LLM involvement at the
retrieval step in a domain and evaluation setting where, to the best
of our knowledge, it has not previously been measured. ... Read more

As the energy consumption of the ICT sector continues to grow, there is an increasing need for developers to reason about the energy efficiency of their code. However, most energy measurement tools operate at the application level and require significant workflow disruption, leaving developers without accessible, in-situ feedback during development. In this thesis, we investigate the technical and practical feasibility of a lightweight, software-based energy measurement tool for Java code snippets, implemented as an IntelliJ IDEA plugin backed by a JShell execution environment and the Linux powercap framework. To evaluate the proposed tool, we conduct a two-phase study. In a verification phase spanning 30 algorithmic problem pairs and 1800 measurements, the tool detects statistically significant energy consumption differences in 83.3% of cases. In a mixed-methods validation study with 22 participants, accuracy in identifying the more energy-efficient implementation rises from 56.8% when relying on source code inspection alone, to 97.7% when using the tool, alongside an increase in participant confidence. Qualitative analysis further reveals that the tool assists in correcting flawed intuitions and provides educational value. These results suggest that fine-grained, in-IDE energy measurement is both technically achievable and empirically beneficial, and constitutes a concrete step toward making energy-aware development a routine part of software engineering practice. ... Read more

Sub-byte mixed precision helps a TinyML model fit the tight Flash budget of a microcontroller (MCU). Selected weights are stored in INT4 or INT2, while sensitive weights stay at INT8. Making such a per-tensor policy deployable on an MCU, however, takes more than a quantization choice. Current deployment stacks couple precision to the firmware across the model format, tensor metadata, and kernels. Thus, changing a per-tensor policy becomes firmware integration instead of simply regenerating an artifact, and each sub-byte model ends up reimplemented from scratch. Packed weights also cost latency. With no native sub-byte arithmetic on these cores, unpacking on the inference path can make sub-byte execution up to nearly 9× slower than INT8.

This thesis presents a manifest-guided deployment framework that decouples the precision policy from firmware execution. An offline packer turns a trained INT8 model and its per-tensor precision plan into a packed FlatBuffer plus a precision manifest, so one unchanged firmware serves different sub-byte policies. On the device, a two-phase Prepare/Eval contract routes each packed tensor to a backend path that keeps weight unpacking off the multiply-accumulate loop, trading a little SRAM for INT8-level latency. We implement the framework in TensorFlow Lite Micro and evaluate it on an Arm Cortex-M33 across five models and three sensing modalities. It reduces model Flash by 31% to 50% and keeps INT4, INT2, and mixed-precision inference within 0.91× to 1.24× of INT8 latency, recovering near-INT8 execution speed while retaining the storage savings of sub-byte weights. ... Read more

Modern ASML lithography systems generate large amounts of diagnostic data during machine failures and performance degradations. To assist field service engineers in identifying root causes efficiently, ASML uses Deterministic Diagnostic Flows (DDFs): structured diagnostic procedures consisting of diagnostic questions and associated failure modes. In practice, however, DDFs are not always sufficient to resolve all issues. Engineers may therefore rely on additional troubleshooting steps, which are recorded in Action Plans (APs) as free-form custom actions and custom solutions. Over time, these records may contain valuable diagnostic knowledge that is not yet incorporated into the existing DDFs.

This thesis investigates whether Large Language Models (LLMs) can assist in augmenting existing DDFs using information extracted from historical APs. More specifically, the work focuses on how to generate additional diagnostic questions and failure modes from free-form diagnostic descriptions. Due to confidentiality constraints and realistic industrial deployment requirements, the study evaluates compact open-weight instruction-tuned language models that can be executed locally.

A central challenge in this task is evaluation. Unlike many traditional natural language processing tasks, there is often no single correct diagnostic question or failure mode for a given situation. As a result, standard reference-based evaluation metrics may fail to accurately reflect the practical usefulness of generated outputs. This thesis therefore investigates both automatic and human-centered evaluation strategies for open-ended diagnostic generation.

Four compact LLMs are evaluated using a dataset constructed from historical APs and corresponding DDF updates. Automatic evaluation is performed using semantic similarity metrics, including BERTScore. In addition, human evaluation is conducted through pairwise comparison experiments, where annotators compare outputs generated by different models for the same diagnostic scenario.

The results show that embedding-based automatic metrics provide useful signals regarding semantic similarity, but do not fully capture the practical quality and diagnostic usefulness of generated outputs. Human evaluation reveals substantial disagreement in the task, with annotators frequently preferring different outputs or judging outputs to be similarly useful. These findings highlight the difficulty of evaluating open-ended diagnostic reasoning tasks using purely automatic methods.

This work contributes to the growing body of research on industrial applications of LLMs by positioning DDF augmentation as diagnostic process repair and by exposing a central methodological gap that emerges under a reference-update operationalization: similarity to historical updates can be measured automatically, but it does not fully explain human preferences or perceived usefulness. These findings indicate that evaluation and validation, rather than generation alone, remain major obstacles to deploying LLM support in practice.
... Read more

This thesis project will be done in collaboration with ErasmusMC's Radiology Group. Frank te Nijenhuis, a former TU Delft Master's Student, current Phd candidate at Erasmus MC, created a proposal for the Perfusion DSA project. For some context, acute ischemic stroke is treated with mechanical thrombectomy. This procedure is performed under real time X-ray guidance. During the procedure, contrast fluid is enhanced while x-ray images are acquired in sequence. This allows for the creation of digital subtraction angiography images to visualize the contrast injection in real time.

This project addresses the clinical challenges of Mechanical Thrombectomy for Acute Ischemic Stroke by optimizing the intraoperative imaging workflow. Currently, interventionists must rely on a trial-and-error process during Digital Subtraction Angiography to find the best imaging angle, which frequently leads to vessel foreshortening or overshadowing while increasing the patient's exposure to radiation and nephrotoxic contrast agents. To streamline this procedure, the project proposes a DRR-Guided Angulation approach that leverages pre-operative CTA scans to generate Digitally Reconstructed Radiographs. This method allows for the identification of optimal C-arm orientations before the procedure begins, ultimately aiming to reduce surgical time and improve the visualization of complex 3D vascular anatomy. ... Read more

The introduction of large language models (LLMs) has transformed the way software is written. With the help of LLM powered code generation the productivity of software engineers has increased all over the world. However, these models are also computationally expensive. The ubiquitous use of these models has raised significant sustainability concerns.

LLM routing aims to reduce the usage of more complex models by routing easier tasks to smaller models. However, existing research on routing primarily focuses on monetary savings and the potential for routing from a sustainability perspective has yet to be explored.

In this thesis we propose an energy-aware LLM routing framework to measure, train and evaluate various routers. We implement our framework and conduct experiments to quantify the energy efficiency of routing and to examine the trade-offs between accuracy and energy consumption. Furthermore, we analyze the overhead introduced by the various routing components. Our results show that routing can reduce energy consumption by up to 15.3\% on the HumanEval and MBPP dataset with minimal overhead when compared to a interpolated baseline. However, overall energy savings were found to decrease significantly as we aim for accuracy targets near the stronger model. These findings show that LLM routing is a viable strategy to reduce energy consumption of LLM code generation in scenarios where achieving maximum performance is not crucial. ... Read more

Large language models (LLMs) increasingly mediate value-laden interactions, yet mainstream alignment methods encode a single normative standard in the model weights and require expensive retraining to change it. This thesis investigates whether representation engineering, a family of methods that steer a frozen model by adding learned directions to its hidden states at inference time, can instead deliver training-free personalisation of toxicity moderation for individual users.We use the Participatory, Representative and Individualised Human Feedback (PRISM) alignment dataset, in which users systematically disagree on what a good response is. From PRISM preference pairs we extract a population-level steering direction with Contrastive Activation Addition (CAA), and we personalise it by composing a small basis of safety directions with weights derived from each user’s dislike-weighted or revealed preferences.On Llama-3.1-8B, population steering moves generations 24–31% closer to the preferred toxicity profile on the hardest prompt categories (p=0.007, paired Wilcoxon signed-rank test), and leaves zero-shot MMLU (Massive Multitask Language Understanding) accuracy unchanged within noise. The intervention is selective: per-record toxicity Mean Absolute Error (MAE) drops by 30–50% precisely where the unsteered model disagrees with human preferences, while already-correct behaviour is left intact. Steering too strongly, however, collapses generation fluency. The per-user extension preserves fluency better than the population direction and reaches the highest preference-prediction accuracy of any arm, shifting model likelihoods toward each user’s preferred response on about 60% of records and reversing the population-MAE ordering, though the per-user margin falls within sampling error at N=197.These results establish representation engineering as a viable, training-free mechanism for personalised LLM alignment on PRISM, bounded by a clear trade-off between alignment strength and generation quality. ... Read more

Automated program repair (APR) is increasingly critical in modern software development, yet language models (LMs) often struggle to capture repository-specific conventions and constraints. Small language models (SLMs) offer a cost-effective and deployable alternative, but their performance depends heavily on high-quality domain-specific supervision. In this work, we introduce a multi-teacher distillation pipeline that generates multi-turn repair trajectories, including both successful fixes and intermediate failures, to construct rich training datasets for method-level APR. We systematically analyze the impact of dataset size, repair diversity, fine-tuning strategies, hyperparameters, and reasoning supervision, aiming to identify efficient and reliable approaches for adapting SLMs to repository-specific repair tasks.

Our experiments demonstrate that parameter-efficient fine-tuning, particularly LoRA with carefully selected adapter ranks, achieves strong performance across reasoning and non-reasoning regimes while maintaining low computational cost. Explicit reasoning supervision is not required for high repair accuracy, but it significantly reduces reasoning trace lengths and inference costs. Dataset diversity and multi-turn trajectories are key to improving generalization and bridging the gap between reasoning and non-reasoning inference. Finally, this study seeks to provide empirical insights into the practical adaptation of SLMs for repository-specific APR, evaluating how strategic choices in dataset design, lightweight fine-tuning approaches, and reasoning supervision influence performance in real-world contexts. ... Read more

With the increasing demand for artificial intelligence (AI), intelligent systems have become deeply integrated into various aspects of modern life, including autonomous driving, smart assistants on mobile devices, and powerful online language models such as ChatGPT. In addition, the emergence of generative models for text and image synthesis has significantly reduced the cost of ac cessing and interacting with information. However, the advancement of these AI applications comes at the cost of ever-growing computational and memory requirements. These requirements pose substantial challenges even for high end computing systems, and become prohibitive when deploying AI models on resource-constrained platforms such as embedded devices and Internet of Things (IoT) nodes. This thesis presents a distributed inference framework for Transformer mod els where we design a fine-grained, channel-wise parameter partitioning scheme. Importantly, the implementation of our framework is also independent of con ventional AI frameworks such as PyTorch, making it efficient, portable, and adaptable to virtually any compute-capable device. We begin by analyzing the computational and memory limitations of main stream hardware platforms, highlighting the motivation to aggregate multiple low-power devices to collectively execute AI workloads. Through software based simulation, we validate the correctness of the partitioned inference scheme and demonstrate that it introduces no functional deviation from unpartitioned single-device execution. The simulation also facilitates precise estimation of data flow and compute demand across multiple collaborating devices. Furthermore, we introduce a full-stack load balancing algorithm that enables adaptive task allocation based on heterogeneous hardware specifications, taking into account factors such as bandwidth, memory capacity, and communication latency. In summary, this thesis proposes a split, practical, and high-granularity Trans former inference framework that is compatible with heterogeneous hardware configurations, offering a promising step toward enabling AI inference distributively on a network of resource-constrained embedded platforms. ... Read more

There has been a steady increase in technologies that leverage Deep Learning (DL) techniques on resource-constrained devices for real-time processing. While DL techniques are adept at recognition tasks, their performance depends on the training process. Training data is seldom fully representative of the deployment scenario, requiring retraining to preserve accuracy. Many works have proposed on-device learning techniques that enable training DL techniques like Convolutional Neural Networks (CNNs) on microcontroller units (MCUs), without requiring data to be sent to the cloud. These methods have yielded promising accuracy improvements while training with low memory footprints. However, limited research has been done on the energy implications of doing so.

This thesis presents methods for energy-aware on-device learning on MCUs. It leverages the principle of updating specific layers of a CNN, proposed in past works, to fit memory constraints. We propose an energy-accuracy trade-off objective based on computational costs (in MACs) and accuracy improvement to select which layers to train. Furthermore, we demonstrate how computationally light search algorithms can adequately maximize the newly defined objective for layer selection. Evaluations show that our approach saves up to 200mJ of energy on-device while yielding simulation accuracies similar to a recent study under the same conditions. ... Read more

Online databases contain extensive collections of (bio)chemical reactions serving as valuable resources for a variety of applications. However, these large datasets often suffer from incomplete reaction data missing, for example, co-reactants and by-products. Machine learning can help to predict these missing molecules in partial reactions. In this study, we adapt an existing transformer model to enhance its capability in completing these incomplete reactions. We retrain the model using a more diverse dataset of atom-balanced ground truth reactions and introduce both soft and hard atom-balance constraints to improve the completeness and chemical validity of the predictions. Our findings indicate that models trained with soft constraints in their loss function do not demonstrate improved balancing performance and require further tuning. Conversely, the implementation of hard atom-balance constraints during constrained beam search, where we restrict predicting tokens that violate the atom-balance of the prediction, effectively improves the performance of transformer-based models in reaction completion tasks. However, this approach also presents the risk of inaccurately balancing reactions; a limitation that is difficult to identify without chemical expertise, underscoring the necessity for reliable ground truth data to evaluate the predictions. ... Read more

This study examines dataset annotation practices in influential NeurIPS research. Datasets employed in highly cited NeurIPS papers were assessed based on criteria concerning their item population, labelling schema, and annotation process. While high-level information, such as the presence of human labellers and item population, is present in most cases, procedural details of the annotation process are poorly reported. Notably, 48% of datasets lack details on annotator training, 43% omit inter-rater reliability, and 28% are not publicly accessible. Temporal comparisons show minor improvements, but no substantial progress in reporting annotation methodology. A complementary analysis of 49 NeurIPS papers published since 2020 shows that researchers often discuss the broader impact of their work, yet do not include datasets or their annotations in these assessments. These findings highlight a lack of standardisation in annotation reporting and call for more robust practices that ensure transparency, auditability, and reproducibility in machine learning research. ... Read more

The Cytomegalovirus (CMV) serostatus, of both donor and patient, plays an important role in allogeneic hematopoietic stem cell transplantation, yet it is only known for 19% of donors in the global database. In this research, the other available data in the global database of the World Marrow Donor Association will be used to predict CMV serostatus for donors who’s status is unknown. In a statistical analysis, features such as sex, registry, ethnicity, age and height were found to be informative. A particular focus was put on investigating the relation between Human Leukocyte Antigen (HLA) and CMV. Previous literature on this relation consists of studies on small cohorts, Machida et al., 1998 (N=125) and Hassan et al., 2016 (N=1 849). The large global database (N=8 707 407 allows us to evaluate this relation for many more different HLA groups and validate their findings using a meta-analysis across registries. In this analysis, the majority of HLA groups showed small effects on the CMV serostatus. However, a few groups showed consistent large increases in likelihood to be CMV seropositive. This indicates that there is a biological relation between specific HLA and CMV serostatus. To predict CMV serostatus, a simple logistic regression classifier was iterated on by adding features and using more complex models. The best performing classifier uses XGBoost on all features in the database. This classifier has an AUC performance of 0.70. Although this AUC is too low to rely on it for patient-donor matching, it does show non-trivial predictive power. The classifier could be further improved by using a better embedding for the HLA that includes the similarities between different HLA alleles. ... Read more