In a growing and highly competitive online grocery market, online grocer Picnic must prioritize optimizing the efficiency of its logistics chain to achieve profitability. Last-mile delivery is a major contributor to operational costs, making its optimization essential. This thesis presents a study on optimizing last-mile delivery operations for Picnic through the application of a Hybrid Genetic Search (HGS) algorithm. The research addresses the Vehicle Routing Problem with Time Windows (VRPTW), factoring in Picnic’s unique operational constraints, including multi-compartment vehicles, a heterogeneous fleet, vehicle time windows, prioritized vehicles, and varied service times.

The study evaluates the performance of the HGS algorithm against Picnic's existing VROOM algorithm in real Picnic instances. Results demonstrate that, on average, HGS consistently outperforms VROOM, achieving significant reductions in total route duration. However, while HGS excels in optimizing route duration, it does not always minimize the number of vehicles used.

This research extends the state-of-the-art Hybrid Genetic Search (HGS) algorithm to tackle the specific challenges of Picnic’s vehicle routing problem. By applying this enhanced algorithm to a real-world setting, it bridges the gap between theoretical optimization advancements and practical industry implementation.

The evolution of malware presents an ever-growing challenge to cybersecurity, impacting individuals, organisations, and nations alike. As malicious actors continue to adapt their tactics to bypass security measures, it becomes imperative to understand the evolutionary patterns of malware to stay ahead in the ongoing arms race between defenders and attackers. The complexity and sophistication of modern malware pose significant difficulties in detection and mitigation, making it crucial to unravel its evolving nature to enhance the existing defensive capabilities.

This research focuses on studying the evolutionary dynamics of malware, examining how variants emerge to circumvent existing security measures. Understanding the mechanisms through which malware evolves makes it possible to identify common patterns and develop strategies to predict the behaviour of certain malware. This work mainly encompasses Windows ransomware, particularly the Conti family, with an additional examination of the WannaCry and Ryuk families. The analysis was conducted primarily by applying dynamic malware analysis techniques to the samples. A total of 143 true-positive Conti samples, alongside 75 WannaCry and 21 Ryuk samples, were collected from reputable sources such as VX-Underground and Malware Bazaar. By utilising the ANY.RUN interactive sandbox for dynamic behavioural analysis, malware samples can be executed in a controlled environment and real-time behaviours, such as file modifications or registry changes, can be collected to discern the malware's underlying functionality and potential impact. In addition, the results obtained from Virustotal, a widely-used online malware scanning platform, are considered to get insights into the detection status of the analysed samples across multiple antivirus engines. Finally, Microsoft Defender Antivirus is utilised to classify the variants and eliminate false positives as much as possible. The tactics and techniques outlined in the MITRE ATT&CK Matrix are used to assess sample behaviour. This framework provides valuable insights into the observed behaviour of samples and the methods employed to achieve specific objectives.

The results answer the question "How do different variants of the malware families succeed in bypassing security measures?" and split the answer into three smaller ones. Overall, it can be observed that different ransomware share common traits, but differences over time and between variants and families can be seen. Some differences exist between the version of the operating system in which the malware is executed. Malware evolves, and the changes of the malware authors are reflected in their malware's behaviour and structure. Some changes persist, whereas new ways quickly replace others. By understanding the evolution and analysing the patterns that emerge, we can build our defences in a way that predicts incoming threats and creates a safer space for everyone.

Low-dimensional datasets, for which each datapoint contains no more than three attributes, are straightforward to visualize with common visualization idioms, such as scatterplots. In order to visualize high-dimensional datasets with potentially thousands of attributes, their dimensionality will need to be reduced. t-SNE is a widely used, state-of-the-art algorithm for non-linear dimensionality reduction. It produces embeddings of the high-dimensional data onto two or three dimensions by using gradient descent to minimize the discrepancy between the probability distributions of the high-dimensional and low-dimensional datapoint similarities, iteratively adjusting the low-dimensional embedding. However, since it is impossible to capture all neighbourhoods over all high-dimensional axes in two or three dimensions, the resulting clustering is merely virtual, only meant to offer an intuition of the dataset's high-dimensional distribution. Our work proposes a number of tools that allow a user to interactively impose constraints based on prior knowledge or assumptions about the dataset and manipulate the underlying probability model with the aim of enhancing an embedding's interpretability, for a better intuition about the data's high-dimensional structure. We demonstrate the effectiveness and limitations of these tools with examples and case studies.

Since large language models (LLM) have been emerged, they took a present role in today’s soci- ety. From society, they also found their way into the field of education that is why in this research paper, we looked into assignments and exams from the TU Delft Computer science and engineering bach- elor and assessed which problems Generative pre- trained transformer (GPT) version 3.5, the current version used by ChatGPT, performs well on (i.e. at least above a pass rate) and on which problems it performs less good (i.e. below pass rate). For our research, we collected assignments by asking professors for consent, to make sure our research was ethically correct. Upon receiving consent, pro- fessors had the option to send material, which al- lowed a deeper analysis, or they could also allow a Brightspace (site where TU Delft courses are hosted) course page scrapping. Once all the ques- tions were gathered, we processed them by prompt- ing them into ChatGPT. We gathered the results and categorized them as wrong or right. We did this all with as few modifications to the questions as pos- sible. The only modifications we did were correc- tions of copy errors from a PDF, for example: C becoming e after copying. From the results, we found that ChatGPT has its limitations, particularly in large code understanding and complex mathe- matical reasoning. However, the model performed well in defining concepts and connecting different ideas. We suggest that GPT lacks a comprehensive understanding of coding principles, which hinders its ability to comprehend code. Future work could include exploring other LLMs like GPT-4 and com- paring their performance. Further work could also look at assignments from other universities, pos- sibly in different educational fields. Additionally, investigating different prompting techniques to en- hance the model’s accuracy and reliability could be done as well.

Using AI to support programming has recently gained a lot of popularity. Researchers have been developing tools to support programming activities using GPT models such as ChatGPT and Codex In this paper, we present the most common pro-gramming activities that these models can support. We show that they have a varying range of success
across solving Code Generation, Code Explana-tion,and Data Visualisation problems, but are often able to solve around 50% of problems on the first try. Multiple tries can raise these averages to 75%. Additionally, specialized tools using GPT models have seen promising results regarding Data Visuali-sation, Software Vulnerability Detection, and Gen-
eral Programming Support. This shows a promis-ing trend, and can mean we will all be pair pro-gramming with AI in the near-future.

Code generation is becoming one of the most important tools in an Integrated Development Environment (IDE) for programmers, be they novices or experts. It allows them to produce code faster, avoid typos and other mistakes, be more efficient and easily turn ideas into code. As such, there are many in-IDE code generation models to choose from, each with their own promises, functionalities and implementation techniques. This report presents the results of a literature survey into the code generation models that have been integrated into programming environments and serves as an overview and analysis of them. The results of this paper provide a set of guidelines for code generation that have been summarized from the selected literature.

The recent emergence of AI-driven code generation models can potentially transform programming education. To pinpoint the current state of research on using AI code generators to support learning and teaching programming, we conducted a systematic literature review with 21 papers published since 2018. The review presents the teaching and learning practices in programming education that utilize these models, the characteristics and performance indicators of the code generation models, and aspects to be considered when utilizing the models in programming education, including the risks and challenges of using code generation models for educational practices. AI code generators can be an assistive tool for both learners and instructors if the risks are mitigated.

In recent years, significant progress has been made in the field of natural language processing (NLP) through the development of large language models (LLMs) like BERT and ChatGPT. These models have showcased remarkable abilities across a range of NLP tasks. However, effectively harnessing their potential requires meticulous prompt engineering and a comprehensive understanding of their limitations.

Additionally, LLMs have attracted attention in the educational domain for their potential to enhance learning and teaching experiences, particularly in fostering the development of computational thinking skills.
This paper aims to explore the potential of leveraging NLP and prompt engineering techniques to generate successful solutions to coding problems following initial failures. Furthermore, the research explores the potential applications of NLP techniques in teaching and learning practices involving LLMs and their potential drawbacks in this context.

The multi-level bin packing problem (MLBP) and its variant problem with partial orders (MLBPPO) are NP-Hard problems that can be applied in a logistical setting to improve efficiency in packing. However, despite their possible use cases, there is little to no literature on how to solve these problems in a reasonable amount of time. In this work, we propose two Integer Programming (IP) models for each problem, one of which is an adaptation from an already existing bin packing implementation, and another with network flow constraints for stronger LP relaxations. The comprehensive experimentation conducted on varying sizes of problem instances suggests that the presented models for the MLBP are highly effective at solving instances with up to 50 items and 5 levels, while neither of the models outperforms the other decisively. For the MLBPPO, the model based on the BP implementation is potent at solving up to 20 items and 5 levels depending on the number of partial orders, while the network flow model cannot compete.

The Multi-Level Bin Packing problem and its variants are some of the most popular combinatorial optimization problems. They have a wide range of real-life applications yet, they are some of the harder problems we know of. In this paper we solve the Multi-Level Bin Packing Problem and a variant of it, Multi-Level Bin Packing Problem with Conflict Constraints, using Integer Programming. We propose two Integer Programming models, a standard one and one with additional flow optimizations. We hypothesized that the second model will have a smaller solution space and consequently an improved performance for both of the problems. However, we find that the second model’s performance is worse and that although it may have a smaller solution space, the comparison of the BnB nodes points towards inconclusiveness.

The Multi-Level Bin Packing problem is a generalisation of the widely-known NP-hard Bin Packing problem. This work aims to investigate approaching this problem, as well as a version including Class Constraints, through integer programming. By modelling the problems in two ways: standard, and with a network flow approach. The studying of the performance of these formulations on various instances, provides a greater insight into the possibilities of integer programming for this purpose. Furthermore, evaluating the two approaches gives an initial suggestion for developing effective models for solving the aforementioned problems.

Multi-Level variants of classic optimisation problems are becoming more noteworthy as the complexity of real life applications increases. In this research we investigate the Multi-Level Bin Packing optimisation problem, which models, for example, global logistics and part manufacturing. We will look at the performance of solving Integer Linear Programming formulations of the Multi-Level Bin Packing problem using IBM ILOG CPLEX Optimization Studio, and compare these results to the performance of simple heuristic-based algorithms to reach conclusions about the usefulness of optimal-solution algorithms for NP-Hard problems. We ultimately find that the simple heuristics leave a large gap in optimality, while the solving time for finding optimal solutions is still too large for practical instances. As such, we conclude that more specialised algorithms are needed that can balance the time cost and optimality, depending on the application.

This paper introduces and studies the Multi-Level Bin Packing Problem with Time Windows. This is a NP-hard problem with real-world applications in logistics. This problem states that items with certain sizes need to be packed inside bins without exceeding their capacity. These bins then again need to be assigned to other bins while minimizing the cost of the used bins. At the same time, each item has a time interval and there must be a common time point between all the items that are packed in the same bin that should be as early as possible. Not much research has been done regarding this problem. In this paper, we suggest multiple models that can be solved using Integer Programming and compare their performance. The results show slight differences in performance between the models.

Authorship identification is often applied to large documents, but less so to short, everyday sentences. The ability of identifying who said a short line could provide help to chatbots or personal assistants. This research compares performance of TF-IDF and fastText when identifying authorship of short sentences, by applying these feature extraction techniques to the television series Friends' transcripts. TF-IDF outperforms fastText in every measurement, but its performance is only marginally better than randomly guessing the original character, reaching an accuracy of 28 percent when making a distinction between 6 characters. Accuracy increases linearly at the same rate for both techniques as the minimum word count per sentence set on the test data increases. TF-IDF's confidence remains constant as this limit is set on either the test or training data, whereas fastText's confidence decreases and increases, respectively. Cross-entropy loss, however, remains constant for fastText and decreases for TF-IDF as the minimum word count set on the test data increases.

In recent years many new text generation models have been developed while evaluation of text generation remains a considerable challenge.  Currently, the only metric that is able to fully capture the quality of a generated text is human evaluation, which is expensive and time consuming. One of the most used intrinsic evaluation metrics is perplexity. This paper researched the correspondence between perplexity scores and human evaluation of scripts for the TV-show \textit{Friends} generated using OpenAI's GPT-2 model.  This was done by conducting a survey taken by 226 participants that evaluated selected scripts on creativity, realism and coherence.  The survey results revealed that generations with a perplexity value close to that of an actual Friends script perform best on creativity, but score low on realism and coherence.  The most realistic and coherent generations were those with a lower perplexity value, while the worst in all fields were the generations with the highest perplexity value.  The research shows that perplexity is not an adequate measure for the quality of generated TV-show scripts.   

Large text corpora used for creating word embeddings (vectors which represent word meanings) often contain a stereotypical gender bias. This unwanted bias is then also present in the word embeddings and in downstream applications in the field of natural language processing. To prevent and reduce this, more knowledge about the gender bias is necessary. This paper will contribute to this by showing how gender bias in word embeddings from Wikipedia develops over time. Quantifying the gender bias over time shows that words in Science and Arts have become more female biased. Family and Career have stereotypical biases towards respectively female and male words, which have steadily decreased since 2006. This provides new insight in what should be done to make Wikipedia more gender neutral and how important the time of writing can be when considering biases in training word embeddings from Wikipedia or from other text corpora.

Artificial Intelligence (AI) is increasingly affecting people’s lives. AI is even employed in fields where human lives depend on the AI’s decisions. However, these algorithms lack transparency, i.e. it is unclear how they determine the outcome. If, for instance, the AI’s purpose is to classify an image, the AI will learn this from examples provided to it (e.g. an image of a cow in a meadow). The algorithm can focus on the wrong part of the image. Instead of focusing on the foreground (cow), it could focus on the background (meadow). This way, by focusing on the background, it could produce a false output (e.g. a horse instead of a cow). To show this, an explanation is needed. For this reason, a variety of methods have been created to explain the reasoning behind these algorithms, called explainability methods. In this paper, six local explainability methods are discussed and compared. These methods were chosen as they were the most prominently used approaches for explainability methods for Convolutional Neural Networks (CNN). By comparing methods with analogous characteristics, this paper is going to show what methods exceed others in terms of performance. Furthermore, their advantages and limitations are being discussed. The comparison shows that Local Interpretable Model-agnostic Explanations, Layer-wise Relevance Propagation and Gradient-weighted Class Activation Mapping perform better than Sensitivity Analysis, Deep Taylor Decomposition and Deconvolutional Network, respectively.