The Deep Neural Network (DNN) has become a widely popular machine learning architecture thanks to its ability to learn complex behaviors from data. Standard learning strategies for DNNs however rely on the availability of large, labeled datasets. Self-Supervised Learning (SSL) is a style of learning that allows models to also use unlabeled data for training, which is typically much more abundant.
SSL is being applied many different data domains such as images and natural language. One such a domain is the domain of graph data. A graph is a data structure describing a network of nodes connected by edges. Graphs are a natural way of presenting many forms of data such as molecules, social networks, and 3D meshes.
The style of SSL that has found the most success on graphs is Contrastive Learning (CL). In CL, an encoder is trained to produce semantically rich representations from unlabeled input data by smartly separating task-relevant information in the input from task-irrelevant information. The encoder backbone most commonly used for Graph Contrastive Learning (GCL) is the Graph Convolutional Neural Network (GCNN).
While GCNNs are the state of the art on many graph data tasks, they suffer from underfitting when made too deep. This is especially a problem for GCL as it prevents encoder complexity to scale with the large availability of unlabeled data.
In this thesis, we investigate this underfitting behavior through the lens of GCNN stability. Stability refers to a model's ability to continue producing consistent outputs, even when its inputs are perturbed slightly. Theoretical work has shown that stability guarantees for GCNNs weaken when their complexity is increased. We confirm experimentally that, in many cases, GCNNs indeed grow less stable when made more complex. This a relevant finding given that learning stable representations is a prerequisite to CL. Additionally, we show in our experiments that, even when trained using CL, stability discrepancies between different GCNN architectures do not disappear. This, in turn, suggests that GCNN architectures with poorer stability may also produce poorer representations. We confirm experimentally that, on at least one dataset, poor stability as a result of architectural complexity can indeed be correlated to a degradation in representation quality.
With this result we provide an additional explanation as to why deeper GCNNs are often found to perform worse in GCL settings. These insights can, in turn, motivate the design of model architectures for GCL that do not suffer from this trade-off between complexity and representation quality.

Raccoon Serious Games develops and hosts educational activities such as escape room events and serious games. They create both physically- and digitally-based escape rooms across many different scales. These events consist of a variety of puzzles and tasks the player(s) have to solve in order to finish or `escape' the event. For their digitally hosted events, the Massive Online Reactive Serious Escape 2.0 (MORSE) system is used for creation and configuration of the needed underlying rules of the event. The system uses the `If This Then That' (IFTTT) principle for creating rules, where a trigger activated by the player/game can initiate a check about the state of the game which then results in an action by the game. In MORSE the user (usually the game host) can choose from the multiple types of triggers, conditions, and actions to create logical statements in the IFTTT format. These statements together form the rules of the game. This system, although a good improvement over the previously hard-coded procedure, has proven unintuitive to program for most of the employees at Raccoon Serious Games. The IFTTT format used is unwieldy to work with for the designers, who have little to no programming background. Furthermore this existing system provides no overview of the rules system making it challenging to visualise the whole game and its dynamics. To solve the unintuitive nature of MORSE, our team designed and developed Feather: A graph-based visual editing tool that is integrated into MORSE. It can generate rule and ruleset logic needed for the client's escape events. It uses visual components and presents the user with a graph of the whole game during the design process. The editor can be used together with all other, earlier existing, features for creating rulesets of the MORSE system. This tool has most of the functionality the current system has, with the possibility of easily extending it with new components. The product was built as an addition to MORSE over the course of 10 weeks. In the initial part of the project a thorough research was performed on the needs of the client as well as useful resources or libraries and design practices for domain specific visual languages. The second part of the project was devoted to the design and implementation of the tool. Throughout the duration of the project a number of user tests were conducted with the employees at Raccoon Serious Games to assess the understanding and usability of the product.