This project will explore different approaches to developing NLP systems such as fine-tuning and prompt engineering for tasks such as sentiment analysis, summarisation, or text classification.

Traffic lights are one of the road transportation systems designed at the road environment to regulate competitions among road users at intersections. In the absence of traffic lights at intersections road users are at risk of road crashes. Although traffic lights serve as a medium of regulating conflicts among road users at intersections, different studies have shown that not all road users comply with the red signals. Thus, classification of red-light violation among drivers will be important to support training and policies in road transportation safety. In this study, decision tree-based model will be developed to classify red-light violations and the associated risk factors among drivers.

In the given scenario, a residential area has two blocks, each with 30 levels, with 12 apartments on each level starting from level five; the total number of apartments is 600. This scenario is on a small scale in Malaysia; some have more blocks. Owners and tenants should be able to book facilities that are limited in terms of numbers (meeting room, reading room, aero yoga room, mini golf range, jacuzzi, sauna, steam bath, multi-purpose hall, squash court, tennis court, etc.) in a timely, automated, and fair manner. This project is a software development project.

Food delivery applications in Malaysia (GrabFood, FoodPanda, AirAsia Food, etc.) played a critical role during COVID-19, and people still use them due to their performance and ease of use. However, those motorcycle riders increase vehicle traffic remarkably at the visitor gate, where each time the security guard needs to register them and call the owner of the apartment to let them in, especially if they've got to pay in cash. This project is a software development project. The goal is to develop a software system that registers a food delivery rider the first time, and then the rider in the future can enter the residential area in much less time by scanning a unique QR code generated by the app when registered (for example), provided that the rider sends a notification before arriving at the condominium to confirm with the owner through the app.

The Bechdel test for film suggests that a film should a) have at least 2 women characters b) they should talk to each other c) about something other than men. This simple test of female roles in film has produced a lot of discussion and some change in film practice. But how about computer games? Is there an equivalent test? How would it apply? is there any progress towards meeting such a thing?

The SmartBody system for graphical characters is available from the Institute of creative technologies at the University of Southern California - see https://smartbody.ict.usc.edu. It uses either a behaviour Markup language (BML) or Python to produce expressive behaviour of both facial expression and gesture. It supports the display of facial expressions using the Facial Action Coding System. This project will create some small examples of situations in which there is an overlay of two different expressions either simultaneously (eg. an angry smile or in rapid succession - anger quickly overlaid by a smile. A small study will evaluate the naturalism and believability of the results.

The Fatima tool kit (https://fatima-toolkit.eu/) allows intelligent characters with the ability to model and express emotions to be animated in Unity. In this project you will use gpt3 plus some rules for expressive4 behaviour to produce an expressive conversational character (ECA) that interacts with the user (or two ECAs the interact with each other). It will be evaluated for believability and successful expressive behaviour in a short study.

Smartbody is a behaviour realisation system for a 3D animated character created at the Institute for Creative Technology at University of Southern California - see https://smartbody.ict.usc.edu/. It can take commends in Behaviour Markup Language (BML) and animate a character or characters, either in its own rendering system or in a games engine such as Unity. This project will select a Large Language Model (like ChatGTP etc), interface that to a sentiment analyser, and link both to a SmartBody character which will say the LLM output with appropriate expressive behaviour. A demo will be created in which the user plays a character is a small story episode and the Smartbody character will be evaluated for how successful it is in responding as an exprressive character.

With the use of Arduion, Android Lily pad, Flora, along with conducting thread and cloth, it has become possible to create wearable items with computer-driven functionality. The idea of this project is design, implement and evaluate a small wearable: see for example https://create.arduino.cc/projecthub/projects/tags/wearables fro ideas. Yes, it may involve sewing - though using a sewing machine is preferable to doing it by hand. It must not involve any face-to-face evaluation or physical contact between participants and the wearable, so online evaluation methods (online design focus groups, video of device in use etc) are part of the requirements

In human dialog, participants are able to interrupt each other at any point. Once a dialog participant has been interrupted they may cede the floor (let another person speak) or alter what they are saying to show they are actively listening. In this project a graphical character will be implemented using Unity and Python that allows some limited behaviour (e.g. head nods, eye brow raise), that is integrated with a speech synthesis system (CereProc) allowing basic lip syncing and output speech. An API will be designed and built over http that will allow a client Python program to stream content (e.g. text for the character to speak and instructions for behaviour), poll the character (establish within a narrow time window what the character has said or done from the streamed content), and interruptible (will allow the system to stop the character gracefully or to stop the character and begin producing new content).

Neural TTS (text to speech) systems can allow very fine specification of speech output allowing the intonation and speech rate from a source speaker to be used to guide a synthetic voice and replicate the source speakers delivery. Much spoken output generated by TTS does not need to be in real time. For example, producing audio for a speech or media performance. CereProc Ltd has developed a prototype system for taking source speech and transcription and creating XML markup to realise the same delivery in a synthetic engine. In this project a graphical user interface (GUI) will be produced to allow interactive tuning of this output. The GUI will be evaluated against a set of users and output compared to baseline TTS.

Current spoken conversational user interfaces (CUIs) are predominantly implemented using a sequential, utterance based, two-party, speak-wait/speak-wait approach. Human-human conversation 1) is not sequential, with overlap, interruption and back channels; 2) processes utterances before they are complete and 3) are often multi-party. Current systems typically wait for a pause of 1.2 seconds or more to decide if a conversational partner has stopped speaking. In contrast, human listeners will respond within, on average 0.2 seconds. Thus, to implement human-like turn taking in a social robot or agent it is required to predict when a conversational partner will stop speaking before they pause. In this project a database of speech dialog with frank, pitch and voice activation detection (VAD) features is used to train a LSTM model to predict voice activation prediction (VAP). The project requires the student to build and train the LSTM and develop evaluation metrics to explore how quickly a system could confidently respond based on this VAP.

There are many cloud resources now available for speech synthesis and speech recognition. In a simple form they can be used to add speech functionality to web pages, or speech functionality to standalone applications and digital games. Many of the systems can be either run on a request by request basis or streamed (to process before completion). Speech recognition can be configures to work slower for better recognition or faster, it can be given pronunciation of expected and unusual words such as proper name. Speech synthesis offers many different voices and often fine control of speech style and intonation. The objective of this project is to produce teaching materials to support the use of these systems and a tutorial to give a hand on experience of using them.

The honours project conceopt should focus on how a social robot could assist someone, through Human Robot Interaction with a health or assistive living need. Assistance and training will be given regarding the robot selected for the project. The student should be a reasonable programmer.

This project will explore the ways in which a social robot could assist children who have severe sight issues. The project will have three phases. In the first phase of the project, the student will explore the literature on research into children learn about the interactions they can have with a social robot. In the second phase, the student will implement and enable a set of interactions to take place with at least one social robot. The student will be required to implement these interactions on at least one social robot. Lastly, the student will deploy the social robot with the implemented interactions in order to evaluate the usefullness of the interactions with a set of students with severe sight issues They will assess which interactions were the most successful.

There are location sharing apps, even Google Maps can do that. These need to be setup in advance, such that the person sharing the information knows the person able to receive the updates. Updates are sporadic and limited to a location, and phone battery life, and minutes since the update. This project looks to extend this functionality to enable location sharing to anyone, and to groups. For example a user may register a temporary online name and be allocated a group code with the service. They then share this group code with their friends via WhatsApp. Now all in that group can see the locations of all others in that group. The user can leave or rejoin the group as they wish, and also be members of several groups. Also updates will include the current speed of movement, direction, location, timestamp, and the username. Further functionality would include allow a parent/guardian to automatically request a location from a child via the app. The server side could be developed with a web based mobile client for testing purposes, but ideally the student taking on this project would use Android Studio to develop a native app which uses the background demon capabilities of Android OS. Requirements: Spatial database (eg PostgreSQL + PostGIS), mobile (or web) client [native Android dev. preferred] , server side dev (eg Python, NodeJS, PHP), web based mapping (eg leaflet.js)

For this project computer vision will be used to return a list of objects in view (eg from a Streetview type image) from which a user can input questions that a LLM (large language model) will be able to answer based on the knowledge gained from the image for the task of navigation. The purpose is to create a service that when provided an image (or set of images) can answer questions related to navigation (ie direction, position). For example: user) which way do I head now? system) towards the building with a red door user) the one next to the bins? system) yes, head towards the bins, and the red door, the cafe will be just after that on your left - it has green windows. Topics: Scene graph, visual grounded models, LLMs, navigation tasks, UI, UX, Geographic Information Systems, Location based services

A challenge in Open Source Intelligence is in finding similar but not identical images which can be used to validate an event occurred. This project will use tools such as YOLO to identify objects in scenes and OpenCV to compare images. The goal is to produce a data processing pipeline that can check a list of images and find related objects to validate they are taken at the same event, but from different angles/times. A VirtualBox VM with the necessary tools installed can be made available if required. Coding in Python preferred.

Build a web-based spatial agent based modelling system for urban transport (Simulated City). This should work with real world coordinates and a map base, implementing multiple agents including the environment (map, traffic lights, vehicles of different kinds including bicycles). The agent based simulation should be able to run on a web platform, this might be in a Jupyter Notebook or as a web app. It should allow for user input of factors such as traffic light sequence timings, different road speeds. Prefered technologies: Python, PostgreSQL/PostGIS, Leaflet.js / OpenLayers.js

IOT Sleep tracker: Most sleep trackers are based on watches but that can be frustrating if you need to charge your watch or don't like wearing a watch to sleep at night. This project will use an Arduino and piezo sensor to build an app which measures movements from the mattress. The arduino will send data to a server for storage and analysis. Analysis could include simple statistics such as length of sleep, but also ML could be used to determine patterns of sleep (shallow, deep, restless). A web gui could be developed as part of the project to visualise trends.

Website can contain valuable data in the form of text (e.g. web text, PDFs, docx files). NLP (inc LLMs) allows extraction of the data within the text, parsing it to find specified items (eg dates, locations, names of people, tools, costs, and other values). This project will be specifically focus on producing an application that performs this job for specified target tasks (eg locations where natural capital tools are used). The output would be a set of web URLs, documents (eg PDFs), and the corresponding values stored in a database (e.g. locations, costs, tool names, organisation using the tools). A UI to search the data could also be developed, including highlighting spatial locations where tools are used and linking to the relevant documents.

GNSS (eg GPS) is a wonderful solution for positioning a device outside. However indoors tracking is much more difficult given the obfuscation of the roof and building materials between the receiver and satellites. There are a number of options for indoor positioning including WiFi fingerprinting, setting up bluetooth beacons, IMU (e.g. foot tracking). There are also solutions based on VPS (visual positioning systems) which use the camera and computer vision to locate the user from a library of previoiusly captured images. This project will develop a simple mobile client which sends image updates from the front camera of a phone held looking upwards to a server. The server will carry out comparisons looking for correspondences within a library of previously captured images. The result would be being able to give a location back to the user which locates them on an indoor map. The project will involve computer vision (eg OpenCV, scikit-image) and development of a web app that takes a camera feed from a mobile device. For this project we particularly want to focus on how well tracking a ceiling will work for positioning around indoor spaces (eg university buildings).

Speech and dialogue interfaces require the application to 'understand' the user's intent. Linking the language model to real-world objects. This project will focus on a few key areas of work - using LLM (eg Llama3, GPT3.5) with a text (or speech) interface to allow the human user to correctly select objects and set instructions related to a real-world environment. The overview of work involves: - collecting a set of photos (ranging from indoor scenes to street views) - using computer vision to segment the images and collect attributes (eg identify object classes, colours, spatial positions) - build a web UI that allows the user to give an instruction (eg what is the number plate of the red car) - construct referring expressions (eg the system builds a useful description of where something is located- such as the bike is next to the house) This work relates to building more natural user interfaces which connect the user and application - and could be used in robotics, multi-user systems, mobile applications, autonomous vehicles etc.

Use public data sets to train machine learning models to identify individuals from their EEG signals.

Vocabularies and ontologies (such as Dublin Core and schema.org) exist to identify and classify learning resources so that teachers and learners can search for suitable resources. The student will investigate existing vocabularies and ontologies such as schema.org, and use these to design and implement a prototype system. https://www.dublincore.org/resources/metadata-basics/ https://schema.org/LearningResource https://dl.acm.org/doi/abs/10.1145/3041021.3054160

The Bechdel test for film suggests that a film should a) have at least 2 women characters b) they should talk to each other c) about something other than men. This simple test of female roles in film has produced a lot of discussion and some change in film practice. But how about computer games? Is there an equivalent test? How would it apply? is there any progress towards meeting such a thing? A previous student project has developed and evaluated a potential test. This project will replicate that test with new subjects, and develop and extend the test.

Projects in user modeling, personalisation and tailored information. Build an app that provides information in some area of interest - this could be a sport activity, craft, tourist activity. The app can provide information and recommendations. Information and recommendations can be tailored according to relevant information about the user - location, time of day the app is being used, and user preferences and skills.

We are increasingly engaging with "digital personalities" online and offline. This project will investigate the use of "digital personalities" and current awareness and attitudes towards Virtual Influences in society. For this project you will survey recent literature about trends in Virtual Influencers and how they are described in popualar media (news, film etc) Build on studies from literature on related technologies such as AI and Bots, and conduct interviews with members of the public to understand their attitudes and concerns. As part of this project you may also implement protoypes or small example systems which demonstrate aspects of influencer system for use in your study.

You will need to: research different privacy mechanims: research different metricsa and emchanisms to evaluate how successful they are for users; identify suitable privacy interfaces and metrics; conduct a usability evaluation of the selected inrerfaces; design and prototype a privacy interface that is intended to imporve on existing interfaces in some way; evaluate the improvement. Metrics for Success: Why and How to Evaluate Privacy Choice Usability Lorrie Faith Cranor, Hana Habib Communications of the ACM Volume 66 Issue 3March 2023 pp 35–37 https://doi.org/10.1145/3581764

Students often find it difficult to schedule their work and decide when to study, what needs to be done. Apps exist which privide this kind of advice and reminders for other personal goals, such as exercise and wellbeing. An app could give personalised suggestions for study material e.g. "watch the following recordings" "try the following exercises" "stdy these handouts before the lecture"; warnings up upcoming deadlines. Devise an app in which students can set learning goals and get personalised reminders relevant to theor courses. The app should take into account external factors such as exam dates and coursework deadlines, weightings and content.The app design will need to consider and respect privacy. Digital twins and artificial intelligence: as pillars of personalized learning models Furini, Gaggi, Mirri, Montangero, Pelle, Poggi, Prandi Communications of the ACM Volume 65 Issue 4 April 2022 pp 98–104 https://doi.org/10.1145/3478281

To develop applications that explore the VR/AR technology available to the Grid and showcase the VR/AR and gaming capabilities to industry and university partners.

You will develop a football training simulation using Unity and Vive. This will support experiments in sports psychology, such as the effects on training of adding different distractions to the simulated environment. This project will require working with equipment and staff in the Grid. A fully successful implementation will support a parallel MSc project by a student in in sports psychology.

Ensemble approaches to modelling topics from large test corpora have shown to improve topic coherency topics and model stability, compared to traditional approaches. However, most attempts so far have concentrated on the evaluation of homogeneous ensembles. The emergence of new topic modelling systems (e.g., BERTopic, Top2Vec) offers the possibility to explore heterogeneous ensembles, mixing these new approaches to classical ones (e.g., NMF, LDA). This project would involve the integration of multiple topic modelling technique in one system, followed by the computation of ensemble topic models (topical alignment and/or weighted term co-association), and finally the evaluation of several metrics of interests.

The data generated by topic models is a rich multi-dimensional set of probabilities, which naturally poses challenges when presented to non-expert users. Over the years, several systems have been built to allow this data exploration by visualising the output of topic models, for example: LDAVis, BERTopic, Topic Mapping (see URL). This project proposes to establish the affordances and hinderances of these many systems empirically by designing a user-based study to quantitatively and qualitatively measuring key metrics. The project would preferably involve the creation of interactive interfaces (one per method) and the iterative development of a rigorous user study, followed by the evaluation of results.

This project is open to students with an interest or idea involving data visualisations, please contact me to discuss your ideas BEFORE selecting this project. Example of projects include: - building bespoke interactive visualisations for complex datasets - user evaluation of interactive data visualisation systems - educational/explainable software involving intuitive data visualisation - spatial data visualisation systems

Visualising the similarity items is a multi-dimensional problem that requires the implementation of mapping strategies, inevitably introducing errors and making compromises. This project proposes to establish a list of viable strategies, implement them and evaluate their performance against selected metrics.

While Python has established itself as the de facto data processing and analysis programming language for years, other languages and their features have been seemingly left out. The project aims to investigate how the programming language Rust can perform when building a text corpus analysis configurable pipeline.

Medical images contain a lot of information that needs to be captured for further analysis and to link it to associated other medical data. In this project you will develop a Knowledge Graph, using the graph-based database system Neo4j and RDF, to model aspects of the human gut. Based on this you will develop a set of semantic query solutions to answer typical questions on the data set provided.

Indexing is a common technique in databases to improve performance. As part of this project you will study the indexing features provided by the graph-based database system Neo4j and design and run a set of experiments to evaluate the performance improvements that can be achieved.

As part of an ongoing research project we model human gut anatomy in the form of a graph database, Neo4j. Other research groups have created similar databases and it is important to be able to systematically identify and understand the variations between two different data sets over the same domain. Similarly, an existing database will evolve over time due to addition/deletion/modification of data elements. Here it is important to be able to systematically identify the differences between different versions of the same database. To achieve this, you will use visualisation techniques that can be applied in Neo4j, for example their Bloom tools, to make it easy for an end user to identify and understand variations in the underlying databases.

As part of an ongoing research project there is a need to integrate data, currently stored in a number of different data repositories, into a single coherent system for analysis purposes. Specifically, in this project you will explore the integration facilities of the virtual graph system Ontop to answer queries across multiple data sets.

Multi-modality image fusion is a technique that combines information from different sensors or modalities to produce a fused image that retains complementary features from each modality. However, effectively training such fusion models is challenging due to the lack of ground truth fusion data. This project focuses on implementing/developing advanced AI models for multi-modality image fusion, e.g. learn to Multi-modality Image Fusion without Groundtruth. If you’re interested in doing this project, please have a look at the papers listed below. https://arxiv.org/pdf/2305.11443.pdf

Clustering is the task of grouping unlabeled data points together based on their similarities. It is an unsupervised machine learning task, meaning that the data points do not have any labels associated with them. In contrast, classification is the task of assigning labels to data points. If the data points are labelled, then clustering can be used as a preprocessing step to improve the performance of classification algorithms. Deep learning (Neural Networks) can learn useful representations from data. This project will focus on implementing and extending the state-of-the-art deep learning models for clustering analysis.

In recent years, deep learning has achieved state-of-the-art performance in various imaging inverse problems, including medical imaging and computational imaging. These methods typically require pairs of signals and their corresponding measurements for training. However, in many imaging problems, we only have access to degraded or undersampled measurements of the underlying signals, which limits the applicability of learning-based approaches. The recent equivariant imaging (EI) framework overcomes this limitation by exploiting the invariance to transformations (translations, rotations, etc.) present in natural signals. EI is fully self-supervised and can recover the signals from their measurements alone. This project focuses on applying EI to different inverse problems including but not limited to medical image (e.g. CT/MRI) reconstruction and image restoration (super-resolution, denoising, debluring, etc.). If you’re interested in doing this project, please have a look at the papers listed below.

Recent advances in AI-based Image Generation spearheaded by Diffusion models such as Glide, Dalle-2, Imagen, and Stable Diffusion have taken the world of “AI Art generation” by storm. Generating high-quality images from text descriptions is a challenging task. It requires a deep understanding of the underlying meaning of the text and the ability to generate an image consistent with that meaning. In recent years, Diffusion models have emerged as a powerful tool for addressing this problem. This project will focus on applying Diffusion Models for image generation, such as painting generation and image fusion. https://arxiv.org/abs/2006.11239 https://arxiv.org/abs/2011.13456 https://arxiv.org/abs/2303.06840 https://arxiv.org/abs/2305.08995

Inverse problems are ubiquitous in computer vision, image processing, and signal processing. Many research or industrial scenarios essentially involve solving inverse problems, such as image super-resolution, image denoising, computational photography, astronomical imaging, medical image reconstruction, etc. Deep learning is one of the main pillars of modern AI due to its powerful learning capabilities. Exploring deep learning and AI solutions for solving inverse problems is a frontier topic. This project will investigate the fascinating and cutting-edge topic of deep learning for inverse problems. The students will also explore and develop the "Deep Inverse" library (see https://deepinv.github.io/deepinv/) - a Pytorch-based open-source library developed by an international and growing team for solving inverse imaging problems with deep learning. Students will be encouraged to publish academic papers if their progress is excellent. DeepInverse: https://deepinv.github.io/deepinv/ Background about deep learning for inverse problems: https://ieeexplore.ieee.org/abstract/document/10004796?casa_token=OWX4u5zTQxUAAAAA:4xqldZHDeZTsQaJLArqxMQqdkHzTnAKi51x2LtAT5BVfo_zWsVCYotmynl08nnqSkvFheAgOBQ

Improving existing process mining methodology, no programming is needed, but the use of one or more process mining tool(s) is required.

To create a data and process model and a corresponding automated process system to read and execute this process model. Programming required.

To analyse twitter data for stock market trends, normally no programming is necessary, sentiment analysis tools will be used.

Optimise a Supply Chain, programming is required for this project.

Create a software system to enable approximate mapping based on semantics of topics and research areas, and other features to create a recommendation system for Talent Finder.

Chatbots are bringing innovation to e-commerce communication with customers. E-commerce companies have been adopting chatbots to provide personalised consumer assistance, particularly chatbot based on Artificial Intelligence. However, everyone knows that no matter how well a chatbot has been trained and developed, there will always be cases where human intervention will be necessary to resolve customer queries. This raises the question of how to identify the moment when the customer is becoming tired or frustrated by the answers given by the chatbot, so it is the right time to resort to human intervention.

The project examines the relevance of chatbots enhanced with AI, regarding customer experience in the context of e-commerce. Based on an in-depth analysis of recent publications in this field, as well as our own field study, we first identify the main causes of poor user experience and frustration that customers experience as a result of their interaction with chatbots; Second, we examine the AI-based techniques that have been proposed to solve these poor customer experiences with chatbots; and finally we propose a design for a chatbot enhanced with a bespoken AI-based technique for e-commerce.

If you have taken my F21IF class in Sem 1 and are interested in Methodologies, Systems Design, SSM, Rich Pictures, User Centred Design, or something else in this area and would like to propose a project then come speak to me.

Modern optimization and machine learning (ML) methods are increasingly used, but still under-exploited, in real-life scenarios related to sustainability. Two such areas I work on are (i) optimization of vehicle fleet plans to reduce carbon emissions, (ii) ML to predict near-future energy demand (to help optimize the use of renewables in energy systems). If you are interested in either of these, we can probably discuss it and come up with a mutually interesting and challenging project.

Social media, particularly twitter (thanks to available APIs) is commonly being mined to gather information of various kinds. E.g. "what are people currently saying about Obama?", "how happy have people in Finland been in the past week", or "how much flu seems to be around in Devon at the moment". Similar to Mike Chantler's project on twitter visualization, this project is to do that sort of thing, but with an emphasis on applications that will be of interest to our contacts in the British Geographical Survey (BGS - see www.bgs.ac.uk). This project will use appropriate text mining techniques to 'sense' from tweets (or other social media) what seems to happening around the planet in terms of, e.g., landslides, tremors, coastal erosion, and other such things.

Google maps, yahoo maps, and others provide APIs that make it possible to build custom maps. For example, if you know the locations of all the bottle recycling bins in your postcode, you could use one of the former APIs to produce a nice map highlighting those bins with a custom gif. Or if you were interested in cycling, and had data about road elevations in areas of interest, you could draw a colour coded visualization of the difficulty of cycling in those arteas. Or, etc ... the world (literally) is your oyser. The finished 'map' is typically an html document full of javascript. However, all of this can be quite laborious to create, even (in fact especially) using the tools provided by the API. This project is to build a tool -- probably command line/linux -- which converts an input text file of simple instructions into the aforesaid html document. For example "10km square centred on Trafalgar Square, marker and label on each statue".

Very expressive type systems commonly used by functional programming languages can be used to specify very complex data types. Those data types can be so complex that they allow encoding of entire mathematical theorems inside a single data type! This expressiveness of type systems enables creation of tools such as the Coq proof assistant (https://coq.inria.fr/). These tools allow the user to specify mathematical structures, state results about those structures (lemmas, theorems), and prove those results correct. Using proof assistants allows us to create machine-checked proofs, which we can trust with an extremely high degree of confidence, much higher than if the proofs have only been looked over by humans. The aim of this project is to serve as an introduction to using proof assistants through first specifying a mathematical object, and then proving some basic properties of it. The project consists of picking one computational model (e.g., finite automata, λ-calculus, Turing machines), learning enough about the Coq proof assistant to specify the selected computational model within Coq, and proving some fundamental properties about it. You can choose to focus on any computational model you like - pick the one you're the most familiar with, or the one which interests you the most. The project is highly flexible in terms of scope. It can be molded according to the student's ambition and interest throughout the project's duration. What will you get out of this project? In terms of practical skills, you will gain experience in writing formal specification, using dependent types, and programming in functional languages. In terms of building up your wider understanding, you will get a first-hand experience of the deep interconnectedness between mathematics and programming. If you enjoy programming, but have always found mathematical proofs difficult and too abstract, this project will give you a completely different outlook on proofs. If you are someone who always had a knack for constructing proofs, you will gain an even deeper appreciation for programming.

When it comes to defining possible behaviors of multithreaded programs accessing shared memory locations, modern programming languages often come with execution models which are (for a multitude of reasons) rather intricate. Those models represent possible executions of a program using graphs whose nodes represent actions taken by the program, and various types of edges represent the relations among the actions. Getting good intuitive understanding of the models of concurrent executions is not easy because people may find it difficult to visualize how the graphs which represent the executions are being built. This project will focus on a version of the execution model used by C/C++ language family. The task is to develop a software which will enable users to input an example program and interactively explore its executions, i.e., the software will help the user build various graphs which represent legal executions of the given program. Think of this software as a teaching aid. The ideal use case is to help people learn how to think about the modern execution models for concurrent programs. Note that you do not need to know much (or anything at all for that matter) about C or C++ to work on this project. The implementation language of the software being developed can be any language you feel comfortable with.

This project is part of a bigger research project to improve on how proofs about programming languages are done. You are not asked to do any proving yourself, the goal is to use the existing parser library to allow the user to specify a data type with an easy custom syntax. The parser converts this syntax into a simple data structure that can then be used by the rest of the code. The implementation would be in standard ML which is basically a simple version of OCaml. For more information, please contact Jan van Brügge (jsv2000@hw.ac.uk).

This project is part of a bigger research project to improve on how proofs about programming languages are done. Every primitive recursive function can be expressed as a fold. The goal of the project is to investigate how this can be applied when bound variables are involved. There already exists a fold that automatically renames variables "out of the way", so the main question is what proofs does the user need to supply and how could they supply it? You do not need to have previous experience with theorem proving, but you have to be interested in it. For more information, please contact Jan van Brügge (jsv2000@hw.ac.uk).

This project is part of a bigger research project to improve on how proofs about programming languages are done. The dual to normal, finite data types are (potentially) infinite codata types. Just like normal data types can be deconstructed with a fold, codata types are constructed with an unfold. There already exists a proof on how to construct the unfold, but it needs to be updated and generalized. There also exists an updated and generalized proof for the fold, so parts of it can be adapted for the unfold as well. You do not need to have previous experience with theorem proving, but you have to be interested in it. For more information, please contact Jan van Brügge (jsv2000@hw.ac.uk).

In 2010, a Flash browser game Manufactoria [1] appeared and quickly gained a cult status. After the end of support for Flash in 2022, a remake of the game was developed and released in 2022 [2, 3]. Manufactoria tasks the player to create machines which do computations by manipulating a queue (reading from the head and writing to the tail). Initially, you should get familiar with the Manufactoria's programming model enough to be able to implement it in a theorem prover, such as Coq [4]. Once the programming model has been implemented, we will look into proving some basic properties of the model, aiming towards proving that Manufactoria's model is as strong as the computational model provided by Turing machines. You will not be expected to spend money on the game. A copy will be provided for you. [1] http://pleasingfungus.com/Manufactoria/ [2] https://pleasingfungus.itch.io/manufactoria-2022 [3] https://store.steampowered.com/app/1276070/Manufactoria_2022/ [4] https://coq.inria.fr/

The main goal of the project is to create a formalization of the algebraic structure of physical units in an assisted theorem prover. After specifying the structure, some fundamental theorems should be established, and an example (preferably the SI system) should be encoded. Goals with which the project can be extended include: - developing a theory of unit prefixes - developing a theory of conversions between unit systems

Humanoid robots are often used for human-robot interaction. As part of the National Robotarium which is currently being built at the Heriot-Watt campus, we purchased several ARI robots [1]. These robots shall be used for human-robot interaction in a vast amount of demos and experiments but in order to do so more effectively, they would require a certain repertoire of gestures. These gestures are arm and head motions that combined would create beat, deictic, iconic or metaphoric gestures that can be played back while the robot is talking to a human. Your task would be to develop these gestures using the simulator and the real robot. This would be followed by an evaluation of those gestures with humans to make sure that they are understood correctly and look natural. [1] https://pal-robotics.com/robots/ari/

As I am teaching a large UG class (SD2), one of the struggles I face is being able to answer all the student queries I receive. Moreover, most of these queries could be answered by looking at the slides. In this project, I would like you to develop a chatbot that is able to answer these queries for me. This chatbot can be based on a Large Language Model such as ChatGPT or something smaller and custom made using something like RASA (https://rasa.com/). The main functionality I would like to have is to be able to feed it PDFs of my slides so that it can automatically learn how to answer questions about them. This projects involves the latest in natural language processing and machine learning. This should be tested with real users and evaluated based on efficiency and likeability.

This lecture should focus on the state-of-the-art in path planning for a robot arm. The arm itself does not need to have sensors and the path planning approach can be offline instead of online. The general aim is to identify the most promising approach for offline robot arm path planning from the literature and to create a lecture that introduces this approach. Ultimately, I would like to use the outcome of this to update the content of the Intelligent Robotics course which is currently focusing on Ant Colony Optimisation (ACO) for one of its lectures. Since the 2nd part of the course focuses on bio-inspired robotics, it would be nice if this lecture could also focus on a bio-inspired approach to robotic arm path planning like ACO.

This project will develop and evaluate a conversational AI system in a task-based domain. The student will learn about concepts and techniques in conversational AI design and implementation, including Natural Language Understanding, Natural Language Generation, and Dialogue Management, and evaluation of dialogue systems. The focus of the project is left open initially and the student can focus on any aspect or sub-task. The dialogue system will be evaluated with human subjects recruited from the university, and it will use both subjective and objective evaluation metrics.

Something to do with cellular automata (such as Conway's game of life).

TBD

Compile a process calculus to Python executable code.

Conway's Game of Life (GoL) is a simple cellular automaton that is capable of arbitrarily complex behaviour (it's Turing-complete). https://playgameoflife.com/ https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life A Penrose tiling is a non-repeating (aperiodic) tiling of the plane. https://misc.0o0o.org/penrose/ An Einstein tiling is the same, but with a single tile: https://www.livescience.com/newly-discovered-einstein-tile-is-a-13-sided-shape-that-solves-a-decades-old-math-problem So far as I know, nobody has implemented a GoL-style system on an aperiodic tiled plane. I think this would be very interesting, and it would be genuinely new. See also Langton's Ant https://en.wikipedia.org/wiki/Langton%27s_ant and the einstein "Hat" https://www.sciencenews.org/article/mathematicians-discovered-einstein-tile

Online cycle route planners exist. Google Maps will do it. However, most do not account properly for hills and difficult terrain; a "shorter" route may be more difficult because it goes up a huge hill, or through an iffy housing estate. Non-google options often have really really bad user interfaces. There seems to be room for something better.

Anything to do with financial technology, both from a business or a technological perspective

Anything to do with propositional, predicate, or modal logic, etc.

Various methods exist to predict market prices --- e.g. technical indicators, candle patterns, price action --- but it's painstaking work (and subject to bias) to work through them manually. So, we can automate it: algorithmic trading (AT) software exists within financial firms, advantaging them over an average trader. A customizable trading robot would help to specify buying and selling conditions, cutting costs and reducing bias.

Various methods exist to predict market prices --- e.g. technical indicators, candle patterns, price action --- but it's painstaking work (and subject to bias) to work through them manually. So, we can automate it: algorithmic trading (AT) software exists within financial firms, advantaging them over an average trader. A customizable trading robot would help to specify buying and selling conditions, cutting costs and reducing bias.

Technical demos have been used in the industry for years to showcase potential core systems of games. Often these demos go onto becoming full blown games, or are used to demonstrate the skill of a developer when looking to apply to industry positions. This project will be focus on procedural technology being applied to a technical demo and showcasing its potential for use in a games. For this project you will need to extensively research procedural generation in games, as well as designing a prototype of the demo. After this you will be required to construct and implement the demo as well as evaluating it using interviews or a focus panel.

Create app to track or plan workouts

Use machine learning to predict/anticipate the price of a market-linked value over a period of time. These predictions can potentially be used as buy/sell indicators.

This interesting online article https://www.theregister.com/2023/08/11/satellite_hacking_black_hat/ and accompanying talk https://www.blackhat.com/us-23/briefings/schedule/#houston-we-have-a-problem-analyzing-the-security-of-low-earth-orbit-satellites-32468 https://i.blackhat.com/BH-US-23/Presentations/US-23-Willbold-HoustonWehaveaProblem.pdf shows that hacking low earth orbit satellites is worryingly easy. In this project, you will either analyse the reasons and mitigations for this (for students on business courses) or explore white-hat hacking of satellites for yourself (for students studying programming).

Conway's Game of Life (GoL) is a simple cellular automaton that is capable of arbitrarily complex behaviour (it's Turing-complete). A Penrose tiling is a non-repeating tiling of the plane. So far as I know, nobody has implemented a GoL-style system on a Penrose tiled plane. I would like to know what happens! See also Langton's Ant

Blockchains are programmable distributed systems and they raise many interesting and useful security concerns. Look up "Ethereum is a dark forest" to see what I mean. You will analyse security of blockchains, either from a business perspective or from a programming/hacking perspective.

Many exploits and legitimate uses of blockchains work by taking advantage of information in the set of pending transactions. This is often called the *mempool*. You will analyse the mempool of a leading blockchain and study it either from the point of view of making trades, or of detecting illegal uses of the blockchain.

As part of the national robotarium which is a joint initiative between Heriot-Watt and Edinburgh Uni to further research in Human-Robot Interaction, we have recently acquired a suit of new robots. One of these robots is the ARI (https://pal-robotics.com/robots/ari/), a humanoid robot for social interaction. To be able to demonstrate the abilities of the robots to visitors and possible collaborators or run simple Human-Robot Interaction experiments, we need an interface for robot control that is easy to use and reliable. To this end, in this project you will develop an application (GUI) to allow the control of PAL robotics ARI robot for running demonstrations in the lab or conducting human-robot interaction experiments. You will have the option to develop one of two types of applications: a web-based interface, running on the robot touchscreen in its chest, for usage by people interacting with the robot; a gui interface for the ‘experimenter’ to monitor the robot’s performance and configure the robot’s plan and goals for the interaction. Either application should be able to provide some of the following features: displaying content on the robot screen, monitoring the robot sensors, execute predefined movements (gestures) or actions, and configure the robot’s behavior.

Various topics possible related to: -Timeseries analyis and forecasting of demand (Metro /Tram) -Traffic incident analysis and recommendations Possible collaboration and internship with RTA (Details to be communicated later). Work with real data Projects allocated based on competitive merit

No code /Low code Machine Learning Automating machine learning training using Low-code and Auto-ML This will involve tool to automatically create ML pipeline and train and test models https://geekflare.com/no-code-machine-learning-platforms/ https://www.databricks.com/discover/pages/the-democratization-of-artificial-intelligence-and-deep-learning https://www.g2.com/articles/low-code-and-no-code-machine-learning-platforms

In the field of natural language processing, the transformer models such as BERT and T5 are providing a lot of fruitful results. These models are also built on the idea of self-supervised learning where they are already trained with a large amount of unlabelled data and then they apply some fine-tuned supervised learning models with few labeled data Self-supervised learning methods have solved many of the problems regarding unlabeled data. Uses of these methods in fields like computer vision and natural language processing have shown many great results. Recent success of Transformers in the language domain has motivated adapting it to a multimodal setting ( Images, audio , video) -multimodal transformer survey https://arxiv.org/pdf/2206.06488.pdf -Vision transformer survey https://arxiv.org/pdf/2012.12556.pdf Possible applications: - Collaboration with research institute in Abu Dhabi ( Satellite Images from drones using colour maps and thermal maps) - Emotions prediction ( text, audio video ) in educational setting or monitoring medical patients Other applications also possible Check this article . (for applications combining language) https://theaisummer.com/vision-language-models/

NLP / Text analytics applications include analysis of text sources like emails, chats, customer feedback, medical records, scientific literature ....Many applications domain like Telecommunications, healthcare, Retail , Travel and Hospitality and Financial Institutions cab benefit from that. This project falls in that domain. Industry collaboration could be sought.

Machine Learning applications have found great sucesses in domains likes Emotions AI, Human computer interaction, Telecommunications, healthcare, Retail , Travel and Hospitality and Financial Institutions,..... Of special interest to me are applications in the field of education, healthcare, sustainability, transportation and well being. All those depend on having or collecting user personalized data and processing those data to derive insights and provide predictions useful as suggestions or actions for the future. Find your field of interest, find your data, ...and get started!! Besides many industry based application derived from research questions and use cases that are of interest to stack-holder using approaches from Machine learning and data analytics

Examine problems in customer behaviour, preferences and profiling to help in retail and sales . Techniques like association rule minings, visualizations, clustering and classifications can be applied Also sources of text like customer reviews, customer support chats can be used for added benefit

Application for sustainability to support saving Energy or improving lifestyle and encourage sustainable practices Theme to go well with Cop28 . Possibility to join exhibitions /competition https://www.cop28.com/thematic-program#:~:text=Each%20day%27s%20programming%20incorporates%20four,through%20both%20content%20and%20speakers.

Students are welcome to bring their own ideas or industry-based use cases. Those can be based on solving problems from their current employer or from personal or career interest. Please research the area of interest, develop a problem statement and discuss with your supervisor to guide you further.

The objective is to compare and implement different explainability models on a sample image data set. Interpretable AI, or Explainable Machine Learning (XML), usually refers to model that can be explained by a human or it decisions can be interpreted. The main focus is usually on the reasoning behind the decisions or predictions made by the model to be more transparent. This is of particular importance for interpreting medical or security related decisions in machine learning models. XAI attempts to unravel the "black box" tendency of machine learning and attempt to explain why a model arrived at a specific decision. Some resources: Data set: https://www.kaggle.com/c/aptos2019-blindness-detection/data Readings: https://aclanthology.org/2021.eacl-demos.17/ https://arxiv.org/pdf/1910.10045.pdf

Principal goal of the project: SPASS, Vampire, and Otter are contemporary resolution-based theorem provers implementing sophisticated reasoning techniques and decision procedures for classes of first-order formulae and formulae in modal and description logics. For certain classes of formulae more than one refinement of resolution leads to a decision procedure. The aim of this project is to use theorem provers to test the potential and limitations of the systems when applied to such classes. The project would involve studying the properties of classes of formulae, their translation into the input language of the theorem provers, running the theorem provers, and evaluating the results. Prerequisites: Knowledge of first-order logic, interest in theorem proving; References: See http://spass.mpi-sb.mpg.de/spass http://www.cs.man.ac.uk/~riazanoa/Vampire

This project is for students interested in investigating haptics as a mode of interaction with technology. This is an intentionally open project and the student can propose their project to Dr Georgiou for an initial discussion. For this project you will need to: research a topic, design a study to investigate your hypothesis or proposal, implement your software and possibly hardware prototype(s), evaluate with users. *Note: as this is a quite open project, you will need to discuss your idea with me before applying for this project. email me at t.georgiou@hw.ac.uk

IoT devices are becoming more and more popular. Small ubiquitous devices can have many uses in the modern smart home. In this project the student will have to research, design and implement an IoT system to be used within assisted living environments for detecting and loging people's activities of daily living in lightweigh and unobtrusive ways, while people's privacy is maintained. The student taking this project will need to have knowledge or a strong interest in hardware prototyping with arduinos, raspberry pi, small sensors etc. *Note: as this is a quite open project, you will need to discuss your idea with me before applying for this project.

This project is for students interested in investigating the use of robots with the context of human robot interactions in the home environment. Specifically, you will need to investigate how people perceive elements of trust and privacy when being monitored by a robot versus other traditional monitoring devices - such as cctv. For this project you will need to: research a topic, design a study to investigate your hypothesis or proposal, implement your software prototype(s), evaluate with users. *Note: The proposal has a basic idea of what will be required, however as this is going to be your project, you are advised to discuss with me before applying for this project. email me at t.georgiou@hw.ac.uk

This project is for students interested in investigating the use wearables within the context of data capture for specialist applications ranging from activities of daily living, to participating in sports. The exact sensors and/or nature of these wearable sensors will be part of the initial discussion with the interested student. For this project you will need to: research a topic, design a study to investigate your hypothesis or proposal, implement your prototype(s), evaluate with users. *Note: The proposal has a basic idea of what will be required, however as this is going to be your project, you are advised to discuss with me before applying for this project. email me at t.georgiou@hw.ac.uk

For this project the student will need to be able to use a number of wireless sensors (arduino/rasperi pi based) and investigate: how they can be made more secure; what security means in that context, and how security affects performance. The challenge and complexity of this project will depend on the student working on it and how deep they want to go into their investigation. As this is a very broad and open project, interested students will need to discuss it with Dr Georgiou as soon as possible T.Georgiou@hw.ac.uk.

This research delves into exploring dynamic sharding techniques within distributed SQL database systems. It focuses on investigating strategies that intelligently distribute data across multiple shards or partitions based on dynamic factors such as data access patterns, workload changes, and resource availability. By analysing the sharding configuration, this research mainly aims to explore the performance, scalability, and resource utilization of distributed SQL databases. The outcome of the research will be important for applications with varying data access requirements and evolving workloads, enabling efficient data management and retrieval while maintaining data integrity in complex distributed environments.

This research aims to explore innovative approaches and strategies to safeguard the confidentiality and integrity of sensitive information within the context of decentralized and distributed computing environments. In an era where data is increasingly stored and processed across a network of interconnected nodes, this study seeks to address the critical challenges posed by privacy breaches and data exposure. By investigating encryption, access control mechanisms, and secure data sharing protocols tailored for decentralized systems, this research aims to provide valuable insights to protect individuals' and organizations' data privacy while harnessing the benefits of distributed computing paradigms.

This research is an in-depth exploration of the security and privacy challenges and solutions within distributed SQL database systems. It involves a thorough examination of various aspects, such as data encryption, access control, authentication mechanisms, and data leakage prevention, with the goal of comprehensively understanding and mitigating potential vulnerabilities. This research aims to provide valuable insights and recommendations for enhancing the protection of sensitive data stored in distributed SQL databases, catering to the growing demand for secure and privacy-compliant data management solutions in today's interconnected digital landscape. By conducting a comprehensive analysis, this research contributes in ensuring the confidentiality and integrity of data in distributed SQL environments.

This research is a collaborative investigation that seeks to bridge the gap between database management systems and it's connection to data mining. The link between database management and data mining holds significant promise for applications in business intelligence, data analytics, and scientific research, ultimately empowering users to harness the full potential of their data resources.

The research aims to investigates the utilization of blockchain technology to establish transparent and immutable records of data's origin, history, and modifications, ensuring data integrity and trustworthiness. By employing blockchain as a decentralized and tamper-resistant ledger, this research aims to create an auditable trail for data, allowing stakeholders to trace its lineage and verify its authenticity throughout its lifecycle. This innovative approach holds the potential to enhance data transparency, reduce the risk of data manipulation or fraud, and provide a robust framework for compliance and auditing purposes in various domains, including supply chain management, healthcare and finance.

This research explores the fusion of blockchain technology with distributed SQL databases to create a robust system for secure and immutable data storage. By combining the inherent security features of blockchain, such as decentralization and cryptographic hashing, with the scalability and query capabilities of distributed SQL databases, this research aims to provide a solution for organizations seeking to ensure the permanence and integrity of their data records. This approach can find applications in various sectors, including supply chain management, finance, healthcare, and more, where maintaining an unchangeable history of data is essential for transparency, trust, and compliance with regulatory requirements.

Since the introduction of generics to Java, type error reporting has suffered. To support research on improving type error diagnosis for Java, you will establish bench marks of Java programs that include generics (type variables), decide on the best error location, suggest fixes etc. Typically, a student will focus on some particular language features of the Java (or Scala). Of particular interest will be techniques to make collecting a benchmark of this kind a more automatic process, for example by mutating type correct programs.

To enable, for example, machine learning based approaches to program plagiarism detection we are in need of sizable collections of plagiarism cases (among cases that are not). The research involves coming up with ways of arriving at such sets with as little effort as possible. This project can be done for various different technologies, depending on the student (typically, Java, Python or Haskell, but others are of interest too).

As part of ongoing work on improving type error diagnosis for Haskell, we are currently lacking in benchmarks set, collections of type incorrect programs, so that we can empirically validate new developments in the field. Your task is, given a particular type system feature of Haskell (type classes, type families, GADTs, or even standard Haskell) is to collect a sizable set of Haskell programs, and annotate these with the best location to report, and possibly some suggested fixes. There are various ways in which this can done (and preferably, somewhat automatically). Trying out various ways of doing this is also part of the task. Possible approaches include internet scraping, and applying source code mutation. You will be granted time to study up on the chosen Haskell type system feature as part of your proposal. It is not expected you to already be fluent in Haskell, but some programming experience in Haskell is advisable.

Look for libraries and tools for Python that can be used to increase the quality of code, reliability and maintainability of Python code. Explain how they work. Develop a tutorial to take a piece of plain Python code and make it more reliable by the use of these tools and libraries.

Industrial Project to be agreed with student's workplace mentor

Industrial Project to be agreed with student's workplace mentor

Industrial Project to be agreed with student's workplace mentor

Open Banking was introduced in 2019 as part of the Payment Services Directive (PSD2) regulationsto give customers greater control over their financial data. A TPP is an authorised online service provider which interacts with a bank, they can with the customers consent allows you to see all your banking products in one place. Money Dashboard is one example of a TPPCurrently testing isn’t complete as there no TPP app in the lower environments (SIT, UAT and PPE*). to test the journey between a TPP and the Sainsbury’s Bank Credit Card app. The solution to this is to create a TPP app (for Android) that will redirect to the Sainsbury’s Bank app (in the lower environments) if the app is installed or Sainsbury’s Bank web site page if the app is not installed, login and give consent before redirecting back to TPP app and displaying Sainsbury’s Bank Credit Card data.This app will include the use of open banking API’s, certificate signing and a user-friendly interface and will allow better testing of this app-to-app journey.*SIT = System Integration Testing, UAT = User Acceptance Testing PPE = Pre-Production Environment

The subnet simulator should allow users to practice subnetting, view network configurations, and test their understanding of IP addressing. It should provide a user-friendly interface and feedback on the correctness of subnetting choices.

Analysing network traffic from a LAN (Local Area Network), or WAN (e.g., internet) is a valuable project that can help you gain insights into network performance, security issues, and user behavior. Legal and Ethical Considerations: Ensure compliance with legal and privacy regulations when capturing and analysing network traffic data. Obtain necessary permissions and inform users about the monitoring. Handle sensitive data with care and implement security measures to protect it.

Creating a web project tracker for students sounds like a not a new idea (valuable ), and it can be a great learning project for those interested in web development.The Student-Advisor Project Management Web Application is a versatile and collaborative platform designed to streamline and enhance the project management process for students and their academic advisors. This web-based tool empowers students to efficiently organize, track, and manage their academic and personal projects while providing advisors with valuable insights into students' progress and needs.

The Graduate Apprentice Prentice Record Tracker is a web-based application designed to streamline and enhance the management of graduate apprenticeship programs. It will serve as a central platform for storing and managing personal information, project details, and mitigating circumstances for graduate apprentices, etc.

The "Multi-threading Processing" project within the realm of computer science delves into the effective utilisation of multi-threading technology to enhance the performance and speed of diverse computational tasks and applications. Multithreading, a programming technique enabling the simultaneous execution of multiple threads (smaller program units), harnesses the potential of multiple processor cores or CPU resources. At its core, this endeavor seeks to implement and refine multi-threaded solutions applicable across a spectrum of tasks and applications. This project specifically employs the Marvin Project, a Java Image Processing Framework, characterised by its pure Java architecture, cross-platform compatibility, and a rich set of functionalities encompassing image and video frame processing, multi-threaded image processing capabilities, seamless GUI integration, plug-in extensibility, and unit test automation, among other capabilities. Ultimately, the project aspires to optimise computational efficiency by capitalising on parallelism for a diverse range of computing tasks.

Wireless Technology Advancements: Recent advancements in wireless communication technologies have opened up new possibilities for communication between vehicles and infrastructure. This project will delve into the latest wireless technologies and their potential applications in VANETs. IoT Integration: The Internet of Things offers a vast ecosystem of sensors and devices that can be integrated into VANETs to collect and share data in real-time. We will explore how these IoT elements can enhance the intelligence and efficiency of vehicular networks. Practical Applications: Through practical experiments and simulations, this project will demonstrate how VANETs can be used to address real-world transportation challenges. For example, by optimising traffic flow through intelligent signaling, waiting times can be reduced, leading to decreased fuel consumption and environmental benefits.

The "Real-time Video Processing" project aims to provide an in-depth exploration of real-time video processing techniques using the Marvin Image Processing Framework. With the rapid growth of multimedia applications and the increasing demand for real-time video enhancements, this project offers an exciting opportunity to delve into the world of video processing. By connecting to a camera device and employing Marvin plug-ins, participants will gain hands-on experience in video filtering, object tracking, augmented reality, motion detection, and data analysis, ultimately showcasing the power of image processing in the context of dynamic video content. Marvin Image Processing Framework: Leveraging the capabilities of the Marvin Image Processing Framework, this project will guide participants through the process of connecting to a camera device and performing various real-time video processing tasks. Practical Applications: Through a series of hands-on exercises and demonstrations, participants will gain proficiency in real-time video filtering for enhancing visual quality, object tracking for surveillance or gaming applications, augmented reality for interactive experiences, motion detection for security systems, and video data analysis for extracting meaningful insights.

The Handwriting Recognition project aims to develop a sophisticated system capable of recognising and converting handwritten text into digital text. This system will involve advanced techniques in image processing, machine learning, and natural language processing to accurately interpret and transcribe handwritten documents.

Sketch to Real using GAN is a form of image-to-image translation task where the objective is to generate realistic images from sketches or line drawings. Generative Adversarial Networks (GANs) have demonstrated significant success in this domain and are widely utilised for such purposes. The transformation of sketches into realistic images using GANs falls within the realm of image-to-image translation, with the aim of creating lifelike images from initial sketches or line drawings. GANs, celebrated for their effectiveness in this area, employ a distinctive adversarial training framework involving a generator and discriminator. The generator produces synthetic images, and the discriminator evaluates them for realism. This dynamic interplay facilitates the creation of high-quality, realistic images from simple sketches, exemplifying the power and versatility of GANs in tasks related to visual content generation.

Examining fake videos and images, commonly known as deep fakes, on social media has become a notable concern. Due to the widespread availability of technology to a broad audience, there has been a noticeable increase in the creation and distribution of deep fake videos across various social media platforms. The term "deep fake" refers to manipulated digital media where an individual's image or video is replaced with the likeness of another person. This trend presents a significant challenge to contemporary society, not only due to the rising prevalence of deep fakes but also because they are used to spread misleading information. Recent research emphasises the broad circulation of deep fake content on social platforms, emphasising the need for urgent development of effective detection methods to tackle this growing problem.

The primary objective of the "Network Simulator 3 by Example" initiative is to modernise and enhance the existing teaching website, currently based on Ns2, in order to align with current industry trends by transitioning to Ns3. This shift includes the creation of a dedicated Ns3 platform with improved capabilities tailored for F29NC - Computer Networks and Communications, as well as F20MX - Mobile Communications and Programming courses. The project emphasises meticulous planning, content development, and a seamless migration process to ensure a seamless transition experience for both students and instructors. The ultimate aim is to establish an invaluable educational platform that not only imparts Ns3 knowledge but also fosters collaborative learning through interactive features and community engagement.

A network monitoring tool is a software application or system designed to oversee, analyse, and manage a computer network. It provides insights into the network's performance, identifies potential issues, and helps administrators maintain optimal functionality. This type of tool is essential for organisations to ensure the reliability, security, and efficiency of their networks.

Developing Blind Vision is a mobile application aimed at assisting visually impaired individuals in navigating their daily lives. The application utilises computer vision and machine learning to analyse the surroundings captured by the rear camera of a smartphone. By providing real-time audio feedback, turn-by-turn navigation, and warnings about obstacles, Blind Vision empowers users with enhanced independence and safety.

The GUI Network Scripts’ Scenarios Generator aims to provide a user-friendly graphical interface for generating scenarios and scripts in NS-2 (Network Simulator 2). NS-2 is a widely used discrete event network simulator for research and educational purposes. This project seeks to simplify the process of creating and customizing simulation scenarios by offering a visual tool that abstracts the complexities of NS-2 script creation.

SDLC Navigator: A Comprehensive Study and Decision Support System for Software Development Life Cycle Models In the rapidly evolving landscape of software development, choosing the most suitable SDLC model is crucial for project success. The proposed project aims to provide developers with a comprehensive understanding of various SDLC models, enabling them to make informed decisions tailored to their project requirements.

In an era increasingly shaped by automation and robotics, the RoboVision project aims to leverage the capabilities of robotics for real-world applications. The emphasis is on creating a system for object identification using popular robotic platform. The integration of artificial intelligence and robotics will empower the robot to visually perceive and identify various objects in its environment.

Software-Defined Networking (SDN) has revolutionised the networking landscape by decoupling the control plane from the data plane, allowing for centralised network management. SDN controllers serve as the brain of SDN architectures, playing a crucial role in orchestrating network resources, optimising performance, and enabling programmability.

Accident Reports typically rely upon a strong narrative, coupled with a few diagrams and pictures. This project will explore to what extent graphical notations arising from Software Engineering and Information Systems can be used to describe and explain accidents involving systems, e.g. railway disasters and infrastructure failures.

Kapture, developed by D-RisQ, is a software requirements tool. Kapture takes structured natural language requirements from which more formal representations can be generated and analyzed. The aim of this project is explore the strengths and limitations or Kapture, as well as alternative forms of formal analysis. Aside: Kapture is written in Java.

Build a graphical simulator that could be used to teach the development of safe and secure embedded software systems in the SPARK (ADA subset). From the perspective of the simulator, there is a wide range of potential domains to choose from, e.g. a railway signalling system, a home security system, or may be you have a better safety/security critical application in mind!

STPA -- System Theoretic Process Analysis -- is a leading Hazard Analysis technique. Developed at MIT, STPA is used for analysing hazards within the context of safety-critical systems, e.g. transportation, medical and national infrastructure. By assisting in the identification of system-level hazards, STPA supports the development of control actions that can be used to prevent potential accidents.

I'm happy to supervise students who want to do a project in cyber security, particularly in areas of application design, authentication, cryptography, digital identity, network security or privacy.

Your task is to build a game that tests users' abilities with cryptography. For different ciphers, a user will be presented with a ciphertext and then asked to answer with the correct plaintext. You might provide a multiple list of potential plaintexts (where at most one is correct) and/or other hints to the user. The user will gain points based on finding each plaintext (possibly some points for partial finds) as well as the difficulty level that might be based on such factors as the type of cipher or difficulty on multiple choice selections. As a start, your game should allow one person to play on their own (against the computer) and you can also look at variations where one or more users can play against one another in competition. You might also investigate collaborative options for the game whereby two or more users work together to guess the correct plaintext.

Software vulnerabilities are a common problem in code which leaves vulnerable many computer systems and applications. The aim of this project is for you to increase your understanding of such software vulnerabilities and to write a tool that reviews code for such vulnerabilities and tests various exploits on the vulnerable code. Some example vulnerabilities are described here: https://seedsecuritylabs.org/Labs_20.04/Software/

There are many situations today in which cyber security decisions are made using machine learning. Most commonly it has been used for detecting anomalies, such as intrusion detection (of network traffic) and malware detection (of software), though there are other areas as well (see Section 4 of https://www.cybok.org/media/downloads/AI_for_Security_TG_v1.0.0.pdf). This is a proposal for a MEng masterclass, output of which would involve the delivery of a lecture, and possibly tutorial or lab, on how machine learning is used for cyber security, with a focus on one security application area.

The lambda calculus is an idealised programming language. Reductions in the lambda calculus allowed us to study evaluation strategies in programming languages. This project is to visualise reductions (best using Python), and to assess and compare different strategies and tradeoffs between termination and efficiency. The visualised reductions will be animated graphs that almost speak to the user. Some of these graphs will be impressive. You can demonstrate the usefulness of what you do either for educational purposes, or for measuring the efficiency of different programs.

Readapt MathLang in Python and use the adaptation to MathLang to analyze mathematical texts.

Different programming languages have different features. This project is to assess when you need an object oriented language, when you need a parallel language, and to build a tool that helps this choice. Already a number of tools have been built and this project is to extend them with new features.

Computer checking the correctness of entire books of mathematics has moved on since the ideas were first introduced independently by de Bruijn in his Automath system and Trybulec in his Mizar system. Since, Computer systems have been created to check the correctness of not only mathematical books but of software and information in general. In this project you will investigate the checking of a a mathematical book in a choice of three computer checkers: Isabelle, Coq or Lean. You will first need to familiarise yourself with one or all of these systems after you have done the background research on them, and then you will need to investigate initial proving of a couple of results you have studied in one of your favorite courses (e.g., it could be your course on discrete mathematics or logic and proof or lambda calculus or Turing machines), and then decide whether you want to do all the work in one prover or you want to compare the three provers in question.

Langauges of Mathematics have played an important role in the creation of the computability theory and also new areas such as the design and verification of programming langauges. There is still no ideal langauge to write mathematics. This project investigates a number of attempts at finding a good language to write mathematics and to also computerise and check the correctness of mathematics.

The famous BNF notation as introduced and used in the Algol 60 report was followed by numerous notational variants (EBNF, ABNF, RBNF etc.). Subsequently, a new Computer Science Metanonation "CSM" was developed. But, CSM does not have yet a full definition or a full implementation. This may be difficult to do. This project will investigate variants of CSM, extracting a full definition and giving a full implementation.

You learned how to write and implement Turing machines to solve certain tasks. But, how do you ensure that the machine is correct and meets its specification? How do you show the properties of your Turing machine (e.g., whether it terminates). This project is to implement the language of Turing machines in Lean (or your choice of provers) and to check the properties of different Turing machines as well as the universal machine.

The project applies machine learning algorithms to analyze the attack patterns within Netflow data, distinguishing benign network behaviour from potential cyber threats. The Netflow data can be aggregated using the NTFA tool and then build machine learning models to detect the attacks.

For this project, the student must utilize LLM and Vector DB tools like Pinecone or ChromaDb to create an LLM agent to respond to user inquiries based on the provided document(s) using Retrieval Augmented Generation.

As machine learning algorithms find their ways in safety-critical systems, such as autonomous cars, robot nurses, conversational agents, the question of ensuring their safety and security becomes important. It is often difficult to explain and interpret machine learning models, yet this seems to be the key to their safe and secure implementation and applications. Explainability of AI is a growing subject area, with different applications, with several tools already available on the market, such as e.g. LIME. These tools start to gradually find their place in AI verification. You will study applications of methods of explainable AI in the area of Verification, and will create your own prototype tools that support these methods. You will have a chance to collaborate with researchers in the lab for AI and Verification: LAIV.uk.

As machine learning algorithms find their ways in safety-critical systems, such as autonomous cars, robot nurses, conversational agents, the question of ensuring their safety and security becomes important. At the same time, neural networks are known to be vulnerable to adversarial attacks --- a special kind of crafted inputs that cause unintended behaviour in trained neural networks. Due to these two factors, neural network verification has become a hot topic in both machine learning and verification communities. It is often described as one of the main challenges faced by computer science and engineering these days. Often, we cannot verify a property with certainty, but can verify it with some degree of probability. There are languages ad tools for Probabilistic verification, for example, PRISM or Probabilistic Prolog. You will study this area and implement your own toy examples using these methods. You will have a chance to collaborate with researchers in the lab for AI and Verification: LAIV.uk.

As machine learning algorithms find their ways in safety-critical systems, such as autonomous cars, robot nurses, conversational agents, the question of ensuring their safety and security becomes important. At the same time, neural networks are known to be vulnerable to adversarial attacks --- a special kind of crafted inputs that cause unintended behaviour in trained neural networks. Due to these two factors, neural network verification has become a hot topic in both machine learning and verification communities. It is often described as one of the main challenges faced by computer science and engineering these days. In this project, you will study the existing methods of neural network verification, and will implement your own toy application/algorithm. You will have a chance to collaborate with researchers in the lab for AI and Verification: LAIV.uk.

You have most likely already used ChatGPT a few times (or a lot!) Have you ever wondered what it actually takes to build a system based on a Large Language Model (LLM) and evaluate it on a real-world task? In this series of projects (check the rest as well!) we will explore the task of text summarisation. This involves taking a long textual input (it could be a news article, notes, or minutes from an interaction like a meeting, or a dialogue, and converting it into a smaller concise document, or set of bullet points. The important thing is to make sure that the output summary faithfully corresponds to the input while mentioning the most salient/noteworthy points. The idea is to explore several popular techniques for fine-tuning an open-source LLM (e.g., Llama 2) starting from the simpler ones (prompt engineering), all the way up to Parameter Efficient Fine-Tuning (PEFT). We will use standard benchmark datasets and SOTA frameworks to evaluate (and potentially train) our models. We can co-develop the project to emphasise more on the features (conciseness, faithfulness, salience), training, data annotation, or human evaluation.

You have most likely already used ChatGPT a few times (or a lot!) Have you ever wondered what it actually takes to build a system based on a Large Language Model (LLM) and evaluate it on a real-world task? In this series of projects (check the rest as well!) we will explore the task of self-critique, or providing feedback using natural language to improve the performance on a downstream task. Take the following example (from [1]): User: I am interested in playing Table tennis. Response: I'm sure it's a great way to socialize, stay active Feedback: Engaging: Provides no information about table tennis or how to play it. User understanding: Lacks understanding of user's needs and state of mind. Response (refined): That's great to hear (...) ! It's a fun sport requiring quick reflexes and good hand-eye coordination. Have you played before, or are you looking to learn? [1] Madaan et al. SELF-REFINE: Iterative Refinement with Self-Feedback. 2023. arXiv. This notion of using language to update a model has received a lot of interest recently which allows for many interesting avenues to pursue: - Come up with a generic style of self-feedback that works for many different tasks (e.g., dialogue response generation, code generation, question answering, error correction, etc). - Focus on one task and create/collect a dataset of feedback that contains desired measurable properties that can be evaluated. In other words we will attempt to evaluate the feedback provided itself rather than just the refined responses. - (More challenging) use self-feedback to train a reward model using reinforcement learning (https://github.com/huggingface/trl) Once we decide on the particular flavour of QA task we are interested in, then we can explore several popular techniques for fine-tuning an open-source LLM (e.g., Llama 2) starting from the simpler ones (prompt engineering), all the way up to Parameter Efficient Fine-Tuning (PEFT). We will use standard benchmark datasets and SOTA frameworks to evaluate (and potentially train) our models. We can co-develop the project to emphasise more on the style of feedback training, data annotation, or human evaluation.

You have most likely already used ChatGPT a few times (or a lot!) Have you ever wondered what it actually takes to build a system based on a Large Language Model (LLM) and evaluate it on a real-world task? In this series of projects (check the rest as well!) we will explore the task of question answering (QA). QA involves trying to automatically answer a user query usually "grounded" on one or more passages (what we refer to as open-book QA) or just relying on the acquired knowledge of the model (closed-book QA). The tricky part (especially with the recent advances in LLMs) is to ensure that the output question is faithful to the user query (and the input passage, if that exists) and not to hallucinate extra pieces of irrelevant or wrong information. There are many interesting aspects in the field of Question Answering that we could potentially explore: - Choose between open-book and closed-book QA. The former involves the component of retrieving the relevant information; this could be either via a search engine (e.g., via a Google search query), or a retrieval engine. This usually depends on the breadth of the domain we will choose to focus on (generic knowledge QA vs. closed-domain questions based for example on the scrape of a website only) - Experiment with different styles of outputs: Provide answers that are less or more verbose, or that exhibit particular linguistic or other rhetoric phenomena (such as repeating part of the question, providing a definition first, giving an explanation, etc.) - Explore more challenging queries, that might require some sort of decomposition reasoning, e.g., complex questions: "How old was Linus Torvalds when Linux 1.0 was released?", "What is the difference between jam and marmalade?" - Experiment with more than single-shot questions, resembling a natural conversation. Once we decide on the particular flavour of QA task we are interested in, then we can explore several popular techniques for fine-tuning an open-source LLM (e.g., Llama 2) starting from the simpler ones (prompt engineering), all the way up to Parameter Efficient Fine-Tuning (PEFT). We will use standard benchmark datasets and SOTA frameworks to evaluate (and potentially train) our models. We can co-develop the project to emphasise more on the features (faithfulness, style of output, complex question, conversational QA), training, data annotation, or human evaluation.

Spectrum-Based Fault Localization(SBFL) aims to identify and rank the program code elements that have caused the test cases to fails. There are multiple approaches in SBFL and this project investigates the effectiveness of each and also develops a tool. Dataset is available for this project

Projects in this area would include data mining techniques applied to the field of education, bioinformatics, social media data OR any application area of your choice.

Mobile Application which could capture an image an d analyze facial expression and identify the emotion. Using CNN(Convolution Neural Network) https://www.sciencedirect.com/science/article/pii/S0031320316301753

Applications of Machine Learning in healthcare/education/speaker recognition/food image recognition

This project is to use efficient Machine learning techniques to perform Bug Triaging. Triaging of bug is to categorize a reported bug to the right developer/severity/category.

This project is basically to identify developer emotions in a collaborative environment/analysis of existing sentiment analysis tools/

An irrigation system that has an automated irrigation to the land using sensors, microcontrollers. The systems is programmed to receive data from the sensors and watering of the farm land is carried out accordingly based on the information received from the soil moisture, humidity-temperature and PH sensors. The mobile app developed will help the farmer to monitor the status of the irrigation system and also alert him.

Fish farming is a tedious process which requires continuous monitoring. The system here will be developed to monitor the conditions of the water - water level, PH etc using sensors. This information is stored in a cloud using a microcontroller . The information is monitored so that any change in ideal conditions will alert the farm administrator and action can be taken. Here, knowledge of use of hardware, sensors, programming of the microcontroller is needed. A mobile app can also be built to monitor and control the system.

Using the example of requirements for software, create its formal specification and apply formal verification methods, such as model checking or automatic theorem proving. Identify the properties of the program that need to be proved or disproved.

Write a program that generates test sequences based on a formal model of the system under test. Investigate the test coverage conditions of the model and conduct an experiment with the aim of the best coverage of the code.

Consider examples of the use of AI in competitions of proof machines. Create a neural network trained on the scenarios of proving statements in the selected theory (polynomial algebra, first-order logic). Using an existing statement proof system or term rewriting system, integrate it with a neural network that provides a hint for each step of the proof.

On the basis of axioms and theorems of predicate logic (propositional or first-order) within the framework of the existing system of term rewriting, create an inference machine. Based on the output scenarios, create a neural network that determines the most efficient simplification step. The result could be an integration of a neural network and term rewriting system, or some other way of hinting at the simplification step.

Investigate the types of backdoors in the program code and create several examples on which to simulate the behavior of the program. Based on the received scenarios, create a neural network for detecting backdoors. In parallel, create a formal description of the semantics of the program's behavior with a backdoor. Create a method that uses the formal semantics of backdoors, and confirms or rejects the result of neural network classification.

Create a formal model of the selected consensus algorithm (Proof of stake, proof of delegated stake, etc.) in the form of a formal model, which can be represented as an automaton, a Petri net, or another type of transition system or process algebra. Consider attacks on the blockchain such as double spending, Sybil attacks, or others. Create a method or use existing algorithms of the model-checking and prove the possibility of an attack under certain conditions (for example, the number of attackers in the network is more than 50%).

Create a neural network that classifies cyberattacks based on existing datasets. Create a program (wrapper) that works as a firewall for a software system to detect and prevent intrusions, using the created neural network. Estimate accuracy and adversarial attack resistance. Consider the problem of verification of the neuron network.

Consider neural networks that work with Big Data in biological research (a database of experiments, substances with certain properties). Develop a technology for searching for a substance with given properties using AI methods.

Cyber security is currently one of the main priority areas of the UK government with its UK Cyber Security Strategy [2] outlining the Government’s plans for ensuring a secure and prosperous cyberspace for UK citizens and businesses. A recent boardgame, designed by Andreas Haggman, aims to model, on an abstract level, the threats and vulnerabilities of the UK and other technology-focused states in the context of on-line business and government. The main aim of this project is to implement Haggman's design for a cyber strategy game on a mobile deviced, preferably Android, and to evaluate the game by running a gaming session with testers and evaluate their experience as well as the game dynamics. The project will proceed in the following stages: - Literature review on cyber security, board game design, and programming mobile devices. - An initial implementation of the game as a multi-player game on mobile devices. - Test and evaluation of the initial implementation, identifying areas for improvement. - A revised implementation based on the above - Test and evaluation of the revised implementation, in terms of software quality and gaming experience.

In safety-critical systems, the validation stage–that is to say a retroactive analysis of the software to ensure the requirements are met–is time-consuming and expensive. Standards defined in various industries such as Automotive (ISO26262), Industrial (IEC61508), Robotics (IEC61508), Medical Devices (IEC62304), and Avionics (DO-178) all have stipulations for how software is treated and validated before it is safe to use. As expected there are many concepts that are common across the board which can be simplified with software. Bazel is a build tool developed by Google that promises to build software quickly, reproducibly, and correctly, guaranteeing that the same input produces the same output now and forever. The applications to building safety-critical software are obvious. In the case of the automotive industry, the rise of self driving cars has put new pressures on software validation. Project complexity is increasing as the expectations around safety grow. A new approach from MIT named Systems-Theoretic Process Analysis presents a method for validating complex projects by analysing the control structures and working back from an accident scenario to provide traceability into the complex set of preconditions that triggered specific unsafe control actions to occur, and is of particular use in the autonomous car industry due to the complexity of the software. Integrating reproducible builds and STPA validation into the software of the car’s control system will make compliance validation cheaper, more secure, and less time-consuming. Objectives: 1. Make Baidu Apollo’s build process reproducible using Bazel 2. Integrate STPA validation into the project’s tests 3. Establish a continuous integration pipeline to run this validation Further Reading: <A href="http://psas.scripts.mit.edu/home/wp-content/uploads/2013/04/Basic_STPA_Tutorial1.pdf">Basic STPA Tutorial</a> <a href="https://bazel.build/">Bazel</a> <a href="http://apollo.auto/">Baidu Apollo</a>

Role-playing games, set in an accurate historical context and supported by a scalable, distributed game engine, can provide an engaging learning environment for both players and game developers: players can learn about the historical and societal context of the game, and game developers can exercise modular design of a complex system in order to achieve scalability for a large number of players. The goal of this project is to develop an AI agent that can act as a NPC or a PC in the previously developed core game engine (JominiEngine [1]). This involves interacting with the game engine, through the same kind of API that is used for the separately developed game clients. The AI agent should be able to interact with the game world and perform basic activites in the three main areas of fief management, household management, and army management. The agent can initially be simple, and rule based, but should be extended to a version that draws on machine-learning techniques to demonstrate increased effectiveness in the game. The project will proceed in the following phases. Literature survey on game design, machine learning and AI techniques; review of the existing game model and code base Design of basic AI functionality (e.g. rule based) and its interaction with the game model Implementation of the basic AI functionality Design of improved AI functionality, drawing on machine-learning techniques Implementation of improved AI functionality Evaluation of the effectiveness of the improved vs. the basic functionality

High volumes of data that are generated continuously are a challenge for many application domains. Efficient implementation of a streaming pipeline is crucial to make processing feasible, and opens the opportunity for applying machine learning techniques on the data stream. The goal in this project is to evaluate and extend an existing system for high-performance stream processing, and to then use simple machine learning techniques on the data stream. The main platform is a recently developed, open source library [1], [2]. In the first step a systematic evaluation of performance and throughput of this library, in comparison with alternatives such as Apache-Kafka [3] should be performed. Possible extensions and enhancements to the performance of the library should be considered. In the second step, simple machine learning techniques should be employed to learn characteristics about the data stream. As underlying data streams, publicly available market data should be used [4], [5], [6], though commercial data integrations could also be optimised [7], [8]. If you are interested in low latency and high throughput data pipelines and want to gain experience with advanced optimization techniques, this might be the project for you! [1] https://github.com/invesdwin/invesdwin-context-integration#synchronous-channels [2] https://github.com/invesdwin/invesdwin-context-persistence#timeseries-module [3] https://kafka.apache.org/ [4] https://github.com/fxcm/ForexConnectAPI [5] https://www.alphavantage.co/documentation/ [6] https://www.dukascopy.com/wiki/en/development/strategy-api/historical-data [7] http://www.iqfeed.net/daytradersetups/index.cfm?displayaction=developer&section=main [8] https://api.tradestation.com/docs/fundamentals/http-streaming

Mobile devices increasingly attract attention as platforms for implementing boardgames. Such boardgames feature a principled game-design that offers high re-play value. An implementation on Android (or other mobile OSs) brings these games to a wide community of users, looking for simple, solitaire or networked games for entertainment. The goal of this project is to extend an existing AI agent for an existing Android implementation of the game "Guerilla Checkers" [1] by Brian Train [2]. This is a checkers-like boardgame with an asymmetric player set-up, a different victory conditions for each side. The current implementation [3], by Richard Gould, allows 2 players to play the game on an Android device. An existing AI, from a previous project, achieves basic game-play but is not competitive against a human player. The main goal is to enhance the AI to make it competitive, and (optionally) to compare it with alternative AI implementations for this game.

Role-playing games, set in an accurate historical context and supported by a scalable, distributed game engine, can provide an engaging learning environment for both players and game developers: players can learn about the historical and societal context of the game, and game developers can exercise modular design of a complex system in order to achieve scalability for a large number of players. The goal of this project is to extend the implementation of a previously developed core game engine. This involves adding in-game functionality of the basic game model, such as enhanced player interaction or more accurate modelling of battles, performance improvements to the core game engine, such as faster database access, and assessing the extended game engine in terms of latency, performance and scalability. The project will proceed in the following phases. <ul> <li> Literature survey and review of game model <li> Design of extensions to the core game engine <li> Implementation of extensions to the core game engine <li> Evaluation of latency, performance and scalability </ul>

Role-playing games, set in an accurate historical context and supported by a scalable, distributed game engine, can provide an engaging learning environment for both players and game developers: players can learn about the historical and societal context of the game, and game developers can exercise modular design of a complex system in order to achieve scalability for a large number of players. The goal of this project is to complete the implementation of a <a href="MScCoreGame.html">previously developed core game engine</a>. This involves adding in-game functionality of the basic game model, implementing a client-server API to allow interaction of players with the core game engine, and assessing the extended game engine in terms of latency, performance and scalability. The project will proceed in the following phases. <ul> <li> Literature survey and review of game model <li> Design of extensions to the core game engine, completing the game model <li> Implementation of extensions to the core game engine <li> Evaluation of latency, performance and scalability </ul>

Follow <a href="http://www.macs.hw.ac.uk/~hwloidl/MScProjects/MScFirstClassSer.html#spec">the link below</a> for a detailed discussion.

Relationships in social networks such as Facebook are typically captured as graphs with users as nodes and relationships as edges. Such graphs become huge when used in the context of social networks. Learning non-trivial relationships and trends in such networks is very time consuming and therefore needs efficient algorithms. In this project, application kernels should be developed for parallel graph algorithms on large graph structures, in order to learn new relationships. The core activity will be to implement parallel versions of the graph traversal algorithms and to assess performance. These application kernels should be implemented in an object-oriented language (eg. Java or C#) and in a functional language (eg. Haskell or ML). The performance of both implementations should be evaluated on a range of large input graphs.

The board-game "Empires of the Skies" is a novel, unpublished board-game currently in design phase. Nowadays, playtesting of new board-games is often done online, using web-based platforms A prototype implementation for this game exists, as a browser game using Java- and Type-script. The goal of this project is to complete the implementation of the board-game "Empires of the Skies", to support the entire game, to develop a simple AI for this game, and then to evaluate both the implementation and the AI. As an optional goal, a simple AI should be implemented for the game, to allow single player usage and to facilitate playtesting.

The goal of this project is to first develop an implementation of a simple BOARD GAME (several options below) for Android-based tablet devices, or on a desktop/laptop, and then to DEVELOP an AI in the game for one of the factions. Choice of technologies is flexible, and should meet the requirements of casual tablet/laptop usage. There are several options of GAMES to implement: - "Kashmir Crisis" (https://brtrain.wordpress.com/2019/08/29/new-game-kashmir-crisis) - More Open Design games by Brian Train (https://brtrain.wordpress.com/free-games/) - Spellcast (https://www.andrew.cmu.edu/user/gc00/reviews/spellcaster.html) - Several games by game designer Neil McCormack - "Origins of World War I" (https://boardgamegeek.com/boardgame/17967/origins-world-war-i) - Schlieffen - Fire&Move - Agricola Express - More board-games and card-games can be discussed for implementation Whatever the game, the project will proceed in the following PHASES: - Literature survey on game design, machine learning and AI techniques; - Review of rules and game mechanisms of the boar-game - Implementation of the board-game as a (multi-player) tablet-based game - Design of basic AI for one of the factions - Implementation of the basic AI functionality - Design of improved AI functionality, drawing on machine-learning techniques - Implementation of improved AI functionality - Evaluation of the effectiveness of the improved vs. the basic functionality

The new Intel Xeon Phi coprocessor is an accelerator card that promises to boost the performance of the host machine by offloading parallel code to a 61-core processor. It brings affordable many-core technology to standard desktop machines, and claims to be easier to program than other accelerators such GPGPUs. The goal of this project is to use a set of common parallel benchmark programs, to run them both on the Xeon Phi and on a departmental many-core server, in order to compare performance on both architectures. In a second phase, a simple parallel program should be developed from scratch, using the Xeon Phi's tool support, in order to assess programability of this new architecture.

Symbolic computation is characterised by performing compute-intensive operations on highly-structured, complex data. The parallelism in these applications is typically dynamic and irregular, i.e. it is generated throughout the computation and varies significantly in size. These characteristics make it difficult for conventional parallel programming languages. As a high-level parallel programming language, the pure, non-strict functional language Haskell will be used. It provides extensions to support both shared-memory and distributed-memory parallelism. The focus in this project is on the latter. This project will use the SymGrid-Par infrastructure for parallel programming, together with the GAP system for computational algebra, to implement one concrete symbolic application. Candidate applications come form the area of computational algebra, and include parallel resultant computation, squarefree factorisation and solving polynomial systems of equations. The thesis will report on the process of parallelising the application, reflect on the sources of parallelism, the suitability of the language and infrastructure for parallelisation, and assess the performance of the parallelised application on our Beowulf cluster.

F1Tenth is a miniature race car, on a 1/10 scale, which is available in the department. The F1Tenth simulator (https://github.com/f1tenth/f1tenth_simulator), is a virtual environment for controlling this car. Control of the car builds on the ROS software which is identical to the real car software we use. In a previous project, a neural-network based AI for over-taking in the simulator has been developed. The goal in this project is to develop this AI further, extend the simulator, and test this environment for multiple cars at the same time. Optionally, the control software can be tested on the physical car as well.

Role-playing games, set in an accurate historical context and supported by a scalable, distributed game engine, can provide an engaging learning environment for both players and game developers: players can learn about the historical and societal context of the game, and game developers can exercise modular design of a complex system in order to achieve scalability for a large number of players. The objective of this project is to enhance a Unity-based client for an existing server for a historical role-playing game. This graphical client should enhance the current functionality of interacting with the game, and introduce new features to improve the general user experience, building on features provided by the Unity framework. The development of the clients should be modular, to maximise the re-use of code between the clients. The usability of these clients should be assessed through user surveys. The project will proceed in the following phases. Literature survey on game mechanics and usage aspects of game clients Design of the software architecure for all clients and delineation of differences Implementation of a text-based game client (for desktops) Implementation of a GUI game client (for desktops) Implementation of an handheld-based game client Assessment of all clients in terms of usability, flexibility and modularity

Docker [1] is a popular virtualisation technology in particular in the context of DevOps. It allows to manage Linux containers, each running its own image, and thereby isolating the software context in a software development project. In contrast to full virtualisation, as in VirtualBox or VMWare, docker images use para-virtualisation, sharing access to the same (host) OS kernel. Para-virtualisation achieves higher performance than full virtualisation, but also restricts the usage to running Linux inside Linux. The goal of this project is to develop teaching material covering: . underlying concepts of (para-)virtualisation . basic docker usage information . some advanced docker usage information . case study of docker usage in software development . or case study of using docker in teaching

Kubernetes [1] is a popular Cloud management infrastructure, specifically for the deployment of Cloud applications. It provides location transparency, avoiding tying the running of an application to one particular machine, resilience and replication, to provide continuous, scalable execution of an application with high resource requirements. The goal of this master class, is to develop teaching material for the practical use of kubernetes, based on Googles web page below [1], and to develop a concrete case study that demonstrates the advantage of a web application running on this platform.

Several web-based platforms for implementing board-games have become very popular in particular during the lock-down period. These platforms typically use a mixture of web-based languages and infrastructures to provide an easy-to-use development platform. The goal of this project is to evaluate one or more of these platforms in terms of their provision of a web-based development platform, and the benefit the developer gets, in terms of a learning experience in web development, from using these tools. Some platforms are mentioned below

Several game engines allow for easy development of computer games. One such platform is BoardGameArena [1], which specialises in the web-based development of digital browser-games using PHP and JavaScript as implementation languages. The goal of this project is to develop teaching material on how to use BoardGameArena to implement serious games, i.e. games that are designed and developed for a particular learning purpose. To this end a case study of implementing a simple board game should be performed. [1] BoardGameArena Studio https://studio.boardgamearena.com

The concept of plaful learning uses gamification concepts to make the learning process more engaging. These can be simple, such as providing badges on achievements, or more advanced, such as space race functionality in quizzes. The main task for this master class is to develop teaching material that exemplifies the usage of platforms such as kahoot or TopHat for playful learning, with a critical reflection on advantages and disadvantages of these platforms.

The RISC-V architecture is a new, open-hardware computer architecture that is increasingly popular and becoming a competitior to established architectures, e.g. ARM. It provides advantages in terms of modularity, flexibility, and open design. The main task in this master class is to give an overview of the main characteristics of this new architecture, mainly for programmers (rather than electrical engineers). This should also critical reflect on advantages and disadvantages. The practical part of the master class should provide some simple programming exercise that elaborates on the differences in architecture: this could use RISC-V vs ARM assembler.

This project is to develop a tool for automatic generation of Attack Defense Trees, or an analysis tool for Attack-Defense Trees.

This project is to design and develop an in-class engagement mobile application around programming code. A Socrative-like app for code.

Design and implement a compiler for complex development and code based operations. Continuous integrations system such as GitLab-CI would be the runtime target.

Covid-19 contact tracing apps have been developed with great urgency. Most of these apps rely on the Google/Apple Exposure Notification (GAEN) API. This project is to investigate these processes of development in relation to the API.

This project is to develop a GitHub-based or GitLab-based programming game for users to improve their programming skills. The project is to use the GitHub API in the building of the game engine.

This project is to build a DevSecOps workflow extension to GitLab for security analysis. Such extension could take the form of adding Attack-Defence Tree modeling for security code review, or integrating a code static analyser such as Infer https://fbinfer.com/ for secure code analysis. This project is also a Master Class on existing features of security analysis existing within GitLab.

This project is to build a GitLab extension for peer-testing and peer-feedback of programming code. The project aims at providing a user-friendly solution for giving and receiving feedback on programming artifacts.

Rust is a recent systems programming language that claims to run blazingly fast, and to prevent segfaults, and to guarantee thread safety. This project is to implement a secure application in Rust to evaluate its effectiveness in secure software development.

Mobile and Web applications are making use of Open APIs to access services. These APIs come with a developer terms of service. This project is to investigate and compare terms of services of existing APIs.

This project is to build and evaluate digital extensions to a deck of knowledge cards on Cyber Seucirty based on the CyBOK (Cybersecurity Body of Knowledge). The card deck is both physical and digital, an extension can target both or a single context. https://www.cybok.org/

The choice of a programming language has major implications, including on security. This project is to investigate how secure or insecure a programming language is with regard to some known weaknesses (CWE, CAPEC, OWASP) by implementing a secure application. This project is also a Master Class on security features of programming languages.

There exists a number of XML Libraries for various programming languages and platforms. Comparison of these XML Libraries exist but focus on speed and features. The aim of this project is to compare various XML parser implementation with regard to security issues (XML entity attacks, cyclic references, remote access, encoding based attacks, ...).

This project is to design, develop or evaluate serious games targeting cyber secutity or software engineering practices. The target audiance (novice/expert), the purpose (educational, training, awareness), and the type (digital, board) of the game is to be determined. This project is also a Master Class on teaching cyber security existing serious games for cyber security.

Typed functional programming languages offer great benefits in term of code safety and security. However some implementation details should be taken care of. This project involves implementing a verifier of programming rules for the OCaml language.

This project is to explore the security and safety aspects of robotic system development and analysis. This project is also a Master Class on safety/security in Robotics.

This project is to explore the languages of CI/CD, DevOps, Cloud Orchestration.

The project is to study and develop strategies for Static Application Security Testing (SAST) using GitLab's Security Dashboard and SemGrep.

Soft robotics is a relatively novel field of robotic design and development and due to its bio-inspired nature there are a vast number of permutations of simplistic soft robots. This project would involve using evolutionary algorithms to evolve a Voxel-based soft robot design.

Robots have the potential to remove humans from hazardous environments, one such environment could be a radiation-contaminated building. Radiation is still a danger to robots and overexposure can lead to damaged equipment. This project would be to work on path planning optimisation using a mobile robotic platform to navigate a room with simulated radioactive hot spots. Suggested background reading: "vPlanSim: An Open Source Graphical Interface for the Visualisation and Simulation of AI Systems by Jamie O. Roberts, Georgios Mastorakis, Brad Lazaruk, Santiago Franco, Adam A. Stokes, Sara Bernardini" and "Modular Robots for Enabling Operations in Unstructured Extreme Environments by Mohammed E Sayed, Jamie O Roberts, Karen Donaldson, Stephen T Mahon, Faiz Iqbal, Boyang Li, Santiago Franco Aixela, Georgios Mastorakis, Emil T Jonasson, Markus P Nemitz, Sara Bernardini, Adam A Stokes" Desire to work in ROS and in Gazebo is required

There are approximately 247,800 miles of road in the UK [1] which can vary in quality from brand new to close to destruction. There are also approximately 72,000 bridges in the UK and recent studies put around 4.4% of those as substandard [2]. It is close to impossible to accurately monitor all of this infrastructure and the cost of embedding sensors can be prohibitive, it has been suggested that crowdsourced IMU data could be used to passively monitor infrastructure as it is traversed by cars. This project would involve creating an application to use a phone IMU and GPS to monitor vehicle journeys and create a database and visualisation that could show the road quality.

Space can be expensive and hard to get, robots are also expensive and hard to get. Both of these factors makes running robotic labs a complex and difficult venture. One way we can tackle this problem is through the implementation of Remote Labs. The project would involve: 1) The integration of a small robotic arm and the Practable.io backend 2) The testing and evaluation of the system with a suitable group of participants

B"ohm trees are infinite objects corresponding to the successive 'unfolding' of a term in lambda calculus; they can be regarded either as a possible semantics of lambda terms, or as an extended language of terms with extended notions of the usual reduction relations on lambda terms. This project, which can be appropriately scoped according to the level and skills of the student, is to study formal representations of lambda terms in a system such as the Agda implementation of type theory. Aspects of the theory of B"ohm trees include: * continuity properties (trees can be given a topology for which application and lambda abstraction are continuous) * extending the Standardisation theorem for ordinary lambda calculus to the extended reduction system on trees; * other topics as they may arise The interested student should have a good mathematical background; an interest in (the foundations of) programming languages; preferably direct experience in the form of our CS Foundations I and II courses

Python is a dynamically typed language with wide application in many data-intensive areas. As such, it has no built-in support for type checking, although users may document their code with the intended types; at present these are unchecked. The aim of this project is to investigate adding types and type checking to an existing python implementation, with a view to evaluating the behaviour and performance of existing python code under a (more strongly) typed discipline. There is considerable scope for theoretical and practical investigations in this area; interested students should discuss with me how they would like to approach the project. Existing work on 'Reticulated Python' may be of use as background material.

The Fundamental Theorem of Arithmetic (FTA), is as its name implies, one of the elementary cornerstones of number theory. Agda is an interactive theorem prover based on intuitionistic type theory, with a rich and highly developed library of elementary mathematical and computational structures. A glaring omission from the library is a complete formalisation of FTA. A concrete objective would be a complete proof of this result, and its successful incorporation into the library.

The K framework https://kframework.org/ (with additional tooling at https://github.com/runtimeverification/k) is, in the words of its developers, "a rewrite-based executable semantic framework in which programming languages, type systems and formal analysis tools can be defined using configurations and rules. " This project concerns doing experiments with representation of, and perhaps reasoning with, programming languages not already supported by K. We also have the offer of services from runtimeverification.com for technical advice and support. Further details of the scope and difficulty of this project available on request. There is room for >1 student to work with me on this.

There has been much recent interest from the mathematics community in so-called *cubical type theory*, a development of intuitionistic type theory in which homotopy-theoretic structure and results may be developed synthetically. Classical structures in homotopy theory include the so called simplicial category, %Delta$ and simnplicial structures, considered as presheaves on $Delta$ with values in suitable categories of interest. Mac lane's "Categories for the Working Mathematician" contains the essential material with which to begin the project. The aim of this project is to develop the general theory of such structures in the Agda theorem prover, an implementation of intuitionistic type theory, and specifically to do so on top of the existing standard library Data.Fin of the dependent family `Fin n` (for `n : Nat`) of finite types. This project is suitable for mathematics students, and mathematically inclined computer science students interested in developing a chapter of classical mathematics in a formalised setting.

Some classical AI logic/'puzzle solving' problems were some of the earliest search problems for which heuristic-guided search procedures were developed; some such procedures may be described in terms of (variously elaborate) proof systems for derivation in suitable logics (as indeed, can classical proof-search procedures). But most puzzle-solving algorithms merely compute solutions, rather than explanations to the human consumer of hoe those solutions were arrived at. The aim of this project is to take an existing solver (or else write one of your own) for a given puzzle game (such as Sudoku etc.) and instrument in such a way as to produce interactive explanations of how to solve a problem instance. There are lots of avenues in which such a project could then be taken: user studies of the appropriateness/intelligibility of the computed explanations; various aspects of additional learning/increase in the expressive power of explanations; etc. More than one student could do this project; but they would need to work on different puzzles/solvers.

This is one of a few different game design projects I'm proposing. They have been left purposefully open so you can come and discuss an area that interests you specifically. As an indie developer myself, I'm looking to work with motivated students interested in making games. PLEASE NOTE: you must email me first to discuss this further before applying for this project. The general idea here is to experiment with, and implement a novel gameplay idea, based on research in the area. You would then evaluate this idea with players and reflect upon your design using this data.

This is one of a few different game design projects I'm proposing. They have been left purposefully open so you can come and discuss an area that interests you specifically. As an indie developer myself, I'm looking to work with motivated students interested in making games. PLEASE NOTE: you must email me first to discuss this further before applying for this project. The general idea here is to research the area of level design and investigate different effects it can have on the player. Perhaps sightlines aren't as useful as expected, or perhaps waypointing and landmarks can be investigated in depth. You would then evaluate this idea with players and reflect upon your design using this data.

This is one of a few different game design projects I'm proposing. They have been left purposefully open so you can come and discuss an area that interests you specifically. As an indie developer myself, I'm looking to work with motivated students interested in making games. PLEASE NOTE: you must email me first to discuss this further before applying for this project. The general idea here is to experiment with the exciting and broad area of user interface (UI) design. Diegetic, non-diegetic and meta UI are become more common in games. What affect does it have on the player, however? You would then evaluate this idea with players and reflect upon your design using this data.

The goal of this project is to leverage Machine Learning approaches to create an intelligent software agent that can teach itself and adapt to market conditions in order to generate successful trading strategies in the stock market. The developed algorithms will be evaluated in real-world set-ups.

Surveillance cameras are typically placed in different contexts which are not known beforehand and that may change dynamically. For example, cameras should be able to cope with background variations such as light changes, weather and seasons in the specific scene, as well as to improve performance with time while it is adapting to the user's scene. Thus, in order to contribute optimally to realizing the system goals, they should be able to adapt to the context they are placed in and its current state. In this work we are going to look into various contextual data from the environment and design algorithms that can leverage this information in order to improve classification performance.

The digital media landscape has been exposed in recent years to an increasing number of deliberately misleading news and disinformation campaigns, a phenomenon popularly referred as fake news. In an effort to combat the dissemination of fake news, designing machine learning models that can classify text as fake or not has become an active line of research. In this work we will investigate viable machine learning approaches for the task of fake news detection.

Within the worldwide perspective of energy efficiency, it is important to highlight that buildings are responsible for 40% of total European energy consumption, which has a contribution of 36% towards greenhouse gas emissions. Since buildings are large contributors of greenhouse gases, it is critical to develop solutions that improves energy savings and achieve sustainability goals in the development of cities. In this project, development of an Internet of Energy (IoE) management system in a smart building is expected for intelligent decision making processes. Internet of energy management systems by collecting sensory data and analyzing them with machine learning techniques will make intelligent decisions to improve energy consumption of appliances in one or several rooms in a smart building. The aim of this project is to propose a model based on the preferences and behavioural habits of the people that live in households and the interdependency of the appliances that are active at the moment. The dataset or collected data will be analyzed in order to provide a suggestion for optimization of the electricity consumption per appliance.

Synthetics data generation has the potential to become an excellent source of ground truth for many computer vision applications. However, the gap between real and synthetic data remains a problem that we are going to address in this task. The goal is to use procedurally-generated data models to synthesize datasets with minimal domain gap.

In this project we will investigate various deep learning neural network architectures for image analysis on satellite data. The aim is providing actionable insights from analyzing the remote sensing data. Use cases may include one or more of the following: Qualitative analysis 1. Vegetation quality 2. Soil quality 3. Sand dune movements patterns 4. Oil spills near the sea 5. Monitoring temperature of seawater near power stations/cooling purposes/Independent sensors 6. Monitoring heat leakage in residential/commercial buildings 7. Monitoring of solar panel conditions 8. Monitoring coastal changes 9. Land use/Land cover Quantitative analysis 1. Detecting Number of Buildings 2. Cars, People etc. 3. Monitoring above the ground high voltage installation 4. Mapping of Geotechnical Investigation 5. Building permit verification 6. Base map updating 7. Disaster mitigation planning 8. Counting Palm Trees 9. Monitoring city night lights 10. Monitoring of building usage 11. Monitoring construction progress This project may involve collaboration with Eaglei71.

Perform domain adaptation from photometric images (visible imager) to radiometric (thermal imager) using a neural network. Proposed methods are (but not limited to): a. self supervision with an attention network b. supervised learning with a GAN Goal of the thesis is good features representation capability of the network. This work will be carried out in collaboration with the Technology Innovation Institute (Masdar City).

Forecasting electricity demand accurately is a critical part in ensuring optimized and cost-effective operation, especially in the context of smart buildings (office, commercial or household). Various Machine learning techniques will be implemented and evaluated comparatively within this project. The project will investigate consumption prediction for different time horizons and at various levels of aggregation, customer profiling and segmentation, as well as including work on exploratory data analysis and different visualisations techniques. Possible collaboration and internship with RTA (Details to be communicated later). Could entail working with real data and might require meetings with external stakeholder.

The goal of this project is to conduct a comprehensive quantitative evaluation of ChatGPT and related LLMs using publicly available datasets on various NLP tasks such as question-answering, summarisation, information extraction, natural language generation, etc.

(Deep)Reinforcement Learning (RL), agents are trained on a reward and punishment mechanism. The agent is rewarded for correct moves and punished for the wrong ones. In doing so, the agent tries to minimize wrong moves and maximize the right ones. The general framework of RL makes it suitable for a large number of applications including autonomous driving, financial services, healthcare, natural language processing, etc. The aim of this projects is to develop and evaluate an RL agent for a specific application domain.

Machine Learning and AI is gradually transforming healthcare services by offering diagnosis and information tools that enable individualised patient management. Examples include, providing personalised treatment recommendations for patients about the right drug and the right dose, as well as customised recommendations based on the person’s lifestyle and behaviour, in order to prevent disease and get ahead of problems that could be troublesome down the road. In this context, machine learning approaches based on medical dataset are proving to be a highly effective strategy in addressing these challenges. The thesis work will focus either at providing a comprehensive study of the application of machine learning to personalised healthcare or will be addressing more in-depth a specific topic such as drug discovery or image processing for automated diagnosis.

The implementation specifications for FL frameworks can vary over a significantly large design space, based on the intended properties and parameterization of the models. In this task we are going to systematically analyse the importance of different quality characteristics as it pertains to key computer vision tasks.

This master’s thesis proposal focuses on normalizing of individual thermal images obtained from a drone mapping process. Then, images are supposed to be stitched using a 3rd party software such as Agisoft’s Metashape. The research aims to address the training of a GAN for normalizing of the thermal (long wave infrared) images. The challenge is to propose a suitable training procedure that minimizes errors in GAN-generated images and produces a homogeneous photorealistic map. Data is already available

This master’s thesis proposal explores the use of transfer learning to seamlessly and efficiently combine two (or more) different camera modalities. Concretely, having a dataset containing RGB images and a dataset containing the correlated thermal images, this proposal has the goal of training a representation embedding for the RGB images (e.g. training an encoder-decoder architecture and then only considering the encoder module), and a representation embedding for the thermal images. The latent spaces containing the RGB and thermal images are then linked together (see “ASIF: Coupled Data Turns Unimodal Model to Multimodal Without Training” [1]). The outcome of the proposal is to use these bridged latent spaces to be able to link any previously unseen RGB image to a subset of previously unseen thermal images The project includes collecting datasets from relevant sources, perform the necessary literature review, and using the aforementioned pipeline to provide simulated and experimental results with (simulated and/or) real data.

This master’s thesis proposal explores the use of a combination of analytical and deep learning-based solutions to obtain accurate monocular metric depth estimation from a sequence of frames. The research aims to address the need of a reliant and robust depth estimator for on-board integration on computationally constrained platforms for online metric depth estimation. The project includes collecting datasets from relevant sources, perform the necessary literature review, and using established computer vision and machine learning techniques to implement a working demo. The expected architecture will be a hybrid analytical-deep learning depth estimation pipeline, combining traditional well-established techniques with state-of-the-art deep learning approaches to improve the performance and accuracy of metric depth estimation. More specifically, the first stage will be tasked of computing a sparse depth matrix –D*- using the inverse pinhole camera model with established sparse optical flow techniques (e.g. Kanade-Shi-Tomasi, or Deep Patch optical flow). The second stage will be a neural network (e.g. ViT, TCN) that considers as input a sequence of RGB-D* frames and outputs the current metric depth map. The final architecture will be tested in a fixed-wing drone scenario flying at ~200 meters of altitude.

Renewable Energy is generally capital intensive relative to its cost of operation and maintenance. The cost of raising capital therefore has a significant impact on the Levelised Cost of Energy (LCOE). Higher confidence of yield prediction throughout the expected life of a renewable energy plan therefore can drive down the cost of energy. This project will train artificial neural networks to better predict energy yield in varying environmental conditions (irradiance, air mass, ambient and panel temperatures, etc) and over long periods of time, to account for cleaning schedules and degradation rates.

What initiatives and technology can influence occupant behaviour to reduce energy consumption, carbon footprint and improve overall sustainability. If technology is to bridge the gap between renewable energy resource and service level need, then what behaviour changes will help to narrow the gap? And can this be achieved without substantially reducing service standards? This project is likely to assess the service level needs of HWU Dubai staff and students and identify opportunities to “behave” more sustainably. The role of technology to inform sustainable choices and the potential to incentivise sustainable behaviour will also be assessed.

A virtual fashion assistant app is a software application that helps users with their fashion choices and provides styling recommendations. The app can be designed to assist users in selecting clothing and accessories that match their preferences, body type, and occasion. The app can use user preferences, browsing history, and social media activity to provide personalized recommendations. The app can include features such as a virtual wardrobe, where users can upload photos of their clothing and accessories, and the app can suggest different outfit combinations. It can also provide styling tips and fashion advice through articles and videos (optional).

Creating an assisted living project involves careful research, thoughtful design, and effective implementation to address the needs of the population and improve their quality of life. Develop wearable devices that collect and transmit health-related data, such as heart rate and body temperature, to a central monitoring system.

This project focuses on leveraging the power of deep learning techniques for medical image recognition and diagnosis. The project will involve collecting or utilizing existing medical image datasets, preprocessing the images, and training a CNN architecture, for example, to learn meaningful representations and features from the images. The model will then be evaluated on a separate test set to assess its performance in detecting and classifying diseases or abnormalities accurately.

The goal of this project is to study an NP-complete problem such as Knapsack problem and proposing algorithms to find optimal and approximate solutions for this problem. The optimal algorithms for NP-complete problems usually take a long time, could be exponential complexity, to generate optimal solutions, especially for hard instance datasets. The aim is to design approximate algorithms to find near optimal answers in polynomial time and compare the performance of the suggested approximation algorithm(s) to the optimal one(s).

The goal is to use the blockchain as a trustless platform to create a trust and reputation system to assess several services based on questionnaires. Those questionnaires will be filled by different users. The aim is to calculate the digital trust values for each service which reflects the users' satisfaction levels. You can use subjective logic or deep learning approaches written on smart contracts over the blockchain to extract the users' opinions which update the trust and reputation system you build.

You will need to collect videos of people signing and their corresponding text transcriptions or use an open-source dataset from the web. You can then use this data to train a machine learning model to recognize sign language. This project will be done on two stages: The first stage is to use images to train your model so that it recognizes the sign language represented by each picture. Next, you need to consider inputting videos, selecting frames, processing it and outputting the recognized English description. Furthermore, the output description could be translated into voice using known APIs.

Handwritten text recognition is a challenging task due to the complexity of the script and diversity of handwritings. However, deep learning techniques have enabled significant progress recently. To develop an HTR model, researchers collect a large dataset of handwritten text images written in specific language and corresponding transcripts. You preprocess the images to improve accuracy and extract features from the images. Then you train a deep learning model like CNNs or RNNs on the features. The trained model is evaluated on a test set to measure accuracy. Once developed, the HTR model can be deployed in real-world applications like mobile apps or web services to recognize handwritten text.

Rational verification is the problem of checking whether a given temporal logic formula \phi is satisfied in some or all game-theoretic equilibria of a multi-agent system. In this project, you will build a tool that takes Simple Reactive Module Language (SRML) code and translates/compiles it to Interpreted Systems Programming Language (ISPL) code. Then use MCMAS (https://vas.doc.ic.ac.uk/software/mcmas/) to verify the resulting ISPL code.

Rational verification is the problem of checking whether a given temporal logic formula Ï• is satisfied in some or all game-theoretic equilibria of a multi-agent system. EVE (Equilibrium Verification Environment) is a tool for rational verification. In this project, you will modify EVE (https://github.com/eve-mas/eve-parity) to work with faster LTL to Parity Automata translator, e.g., Owl (https://owl.model.in.tum.de/).

Rational verification is the problem of checking whether a given temporal logic formula Ï• is satisfied in some or all game-theoretic equilibria of a multi-agent system. EVE (Equilibrium Verification Environment) is a tool for rational verification. In this project, you will modify EVE (https://github.com/eve-mas/eve-parity) to work with faster parity games solver, e.g., Oink (https://github.com/trolando/oink). EVE currently uses PGSolver (https://github.com/tcsprojects/pgsolver).

Rational verification is the problem of checking whether a given temporal logic formula Ï• is satisfied in some or all game-theoretic equilibria of a multi-agent system. EVE (Equilibrium Verification Environment) is a tool for rational verification. Currently, EVE only support games with LTL objectives. In this project, you will extend EVE to support games with mean-payoff objectives. In particular, you will do the following - Extend EVE (https://github.com/eve-mas/eve-parity) to multi-player mean-payoff games - Implement algorithm in [1] to solve relevant decision problems - Integrate mean-payoff solver to EVE, e.g., https://github.com/romainbrenguier/MeanPayoffSolver Reference: [1] Gutierrez, Julian, et al. "On computational tractability for rational verification." International Joint Conferences on Artificial Intelligence, 2019.

PRISM-games is an extension of PRISM, designed for the verification of probabilistic systems. These systems can incorporate either competitive or collaborative behaviour, modelled as stochastic multi-player games. In this project, you will explore a realistic scenario of a multi-agent system and model it using PRISM-games. Subsequently, you will conduct an analysis of its game-theoretical properties, such as Nash equilibria.

EVE (https://github.com/eve-mas/eve-parity/) is a tool that can be used to synthesise strategies in multi-agent systems, which are modelled as concurrent games. These synthesised strategies can be viewed as conditional plans for the agents. In this project, you will employ approaches from explainable planning (XAIP) to elucidate the synthesised strategies, thereby enhancing their comprehensibility.

Quantum computing harnesses the quantum mechanical properties exhibited by its unit of information, namely qubits, to perform computations. A major research subtheme of quantum computing is quantum cryptography, which aims to design communication protocols that allow secure message transmission between few parties. Arguably, Quantum Key Distribution (QKD) is said to be the most widely applicable quantum cryptography protocol due to its several notable strengths, including its ability to detect the presence of eavesdroppers attempting to intercept the communication. The core ideas of QKDs are derived from a few simpler quantum games. While quantum properties, especially entanglement could be used to design strategies with winning probability greater than all possible classical strategies on these games, they are often perceived as counterintuitive. Therefore, this project is dedicated to: 1. Studying these quantum games and the QKD protocol while exploring their variations. 2. Designing demonstrations to visually support the understanding of these quantum games and cryptography protocols by employing suitable programming languages.

Placing virtual characters and robots in the real world, so they can interact with their environment can be quite challenging, this is quite common case when interacting with simple items like the floor and doors. To solve the issue robust detection and a good level of inverse kinematics is needed. For the masterclass you will be required to research the issue, look at topics like detection, kinatics and new advances/algorithms (probably AI-based). Plus produce materials to explain the issue, methods/algorithms, and a practical solution preferable for both virtual and real interactions (aka. simulations and robotics). Here is a source explaining the issue for doors: https://www.vox.com/videos/22661048/video-game-development-door-difficulty-design And a video from one of our previous student: https://www.youtube.com/watch?v=hgrHkBTii5c I do not have readily available examples for robotics but hopefully you get the idea.

The human immune system can effectively protect us from viruses and other invaders. Algorithms inspired by this have been developed, the so-called artificial immune systems (AIS) You are free to explore any ideas or existing immune-inspired algorithms to solve any problems you like. Previous projects include using AIS for the following problems (you can do similar but not the same, or select any problems that interest you): 1. Searching best neural network architecture 2. Playing games 3. Make Machine Learning fair 4. Anomaly detection 5. Cybersecurity

Machine Learning may make unfair decisions, for example, it may have bias toward ethnic minorities and/or vulnerable groups. In this research, we would like to investigate how to mitigate the discrimination of machine learning algorithms.

AI and ML-related project.

You can proposal any novel ideas on using swarm intelligence to perform data clustering, including clustering mixed data, dynamic data, or networked data. Examples: 1. J. Ji, W. Pang, Z. Li, F. He, G. Feng and X. Zhao, "Clustering Mixed Numeric and Categorical Data With Cuckoo Search," in IEEE Access, vol. 8, pp. 30988-31003, 2020, doi: 10.1109/ACCESS.2020.2973216. https://ieeexplore.ieee.org/document/8993805 2. Albalawi H., Pang W., Coghill G.M. (2020) Swarm Inspired Approaches for K-prototypes Clustering, Advances in Computational Intelligence Systems. UKCI 2019. Advances in Intelligent Systems and Computing, vol 1043. Springer, Cham. https://doi.org/10.1007/978-3-030-29933-0_17 https://link.springer.com/chapter/10.1007%2F978-3-030-29933-0_17

Have you heard of the one-pixel attack? https://arxiv.org/abs/1710.08864 It can fool advanced deep learning algorithms by only changing only one pixel of an image. Recently Sparse attack is becoming more and more popular: https://openaccess.thecvf.com/content/CVPR2023/papers/Williams_Black-Box_Sparse_Adversarial_Attack_via_Multi-Objective_Optimisation_CVPR_2023_paper.pdf In this project, we will use immune-inspired algorithms to develop attacking methods in order to fool existing deep learning algorithms, which can raise awareness of security and safety for machine learning. We wil aslo develop protection methods to protect machine learning algorithms from potential attacks, and this will also be inspired by immune systems or evolutionary algorithms.

This is an open research question, and you can use swarm to solve any problems that you are interested.

The goal of this project is to study, understand and validate the research issues of cellular-connected drones with respect to handover and interference when supported from the existing terrestrial cellular infrastructure. The students will be involved in reading research papers, analyze mathematical models of interference for drones, estimate handover criterias, use existing real-time frameworks to validate the research issues.

Investigate current attitudes towards artificial intelligence (AI) in different parts of society, including the general public, media, and AI practitioners. This project will involve a survey of recent research literature on AI trends as well as the portrayal of AI in the popular media. Building on recent studies in other parts of the world, interviews will be conducted with members of the public to understand concerns about recent trends towards wider deployment of AI. This project may also involve the creation of small AI artefacts (e.g., such as chatbots) to help guide the study.

This project will explore the use of modern machine learning techniques (e.g., deep learning, reinforcement learning, etc.) for different problems in automated planning. While automated planners are good at making goal-directed plans of action under many challenging conditions, the addition of machine learning tools to the process could lead to optimisations in terms of more efficient planning or higher quality plans. Also, some symbolic aspects of the planning problem (e.g., action specification in PDDL) could be learnt by using machine learning techniques. Applications of this task will be applied in planning scenarios such as robot control or human-machine interaction.

This project will explore the use of large language models (LLMs, e.g., ChatGPT) for different problems in automated planning. While automated planners are good at making goal-directed plans of action under many challenging conditions, the addition of large language models could help automate parts of the planning process in terms of more efficient planning or higher quality plans by providing commonsense guidance. Some symbolic aspects of the planning problem (e.g., action specification in PDDL) could be built using such techniques. Applications of this task will be applied in planning scenarios such as robot control or human-machine interaction.

This project will explore the state of the art in generating creative content (e.g., artwork, poetry, prose, music, etc.) using AI techniques. The project will choose a subset of mediums and attempt to generate new creative content by implementing generative AI techniques (e.g., machine learning). An evaluation will be performed to compare AI-generated content against traditional human-generated content.

This project will explore the use of artificial intelligence techniques in games, with a particular focus on automated planning and related approaches. The student will survey the state-of-the-art in some aspect of AI game playing and focus on applying new AI algorithms to a game environment. Such techniques could be used to control artificial game players or automate particular aspects of the game environment (e.g., board layout, puzzle creation, move suggestion, etc.). This project will involve a significant amount of software development for AI techniques and the game environment.

This project will explore the problem of explainability in AI systems (XAI) using automated planning tools (XAIP). Automated planners provide a causal model of states, actions, and plans which will serve as the underlying framework for explaining agent behaviour in particular circumstances. New approaches to plan explainability will be explored and implemented using existing planners that may be augmented and tested using representative planning domains.

Automated planning systems are good at generating goal-based plans of action but typically require a fixed model. Human-in-the-loop planning enables a user to introduce constraints into the planning process which affects the plans that are generated. This project will build a suitable interface for an off-the-shelf automated planner to enable certain types of constraints to be specified by the user (e.g., preferences, temporal, goal ordering constraints) and control the planning/replanning process.

BitTorrent is the de-facto peer-to-peer (P2P) standard. Unfortunately, its lack of security has led to it being mainly used for illegally exchanging gray content (e.g. copyrighted materiel). The objective of this project is to add authentication, authorisation, confidentiality and data integrity to BitTorrent. MonoTorrent, which has a much simpler source code than Vuze, will be used for implementation.

To be discussed face-to-face. You can get inspired by reading Saarah's dissertation, which was ranked second at an international British Computer Society competition http://www.macs.hw.ac.uk/cs/project-system/projectdata/archive/2019/ugcse/sw36_full_text.pdf

The project covers a few topics, including: - Possible use of deep reinforcement learning to control the player - Potential for covering the interface with the real world by, e.g., doing image acquisition of what a player has in their hands + dominoes that were played to feed them into the AI.

Existing anti-malware products struggle to keep up with the hundreds of thousand of malware that appear on daily basis. Previous research in our University have obtained interesting results by applying machines learning techniques. In this project, you design and build a prototype of an anti-malware that uses those results. The anti-malware can be built by either writing it from scratch, or by adding rules/signatures into an existing anti-malware (e.g. ClamAV). Arjun Rajeev did implement a first functional version of this software. You will add features and possibly re-implement some.

The objective of this project is to provide an easy-to-deploy, secure and scalable student attendance monitoring system. The new system should be able to automatically collect student attendance information (e.g. by using NFC, fingerprint readers, or face recognition) without an (major) intervention from the lecturer. The lecturer will still have a fail-over interface where they can enter/edit attendance information. The system will be able to generate automatic attendance notification emails to the school administration office (e.g. when a student misses 3 lectures in a raw).

Blockchain can be defined as an online distributed ledger, with the possibility to store virtually any information on it. Cryptocurrencies, such as Bitcoin, are based on blockchains. We aim to investigate the use of blockchains to different sectors of activity, e.g - Medical records and other health-related applications. - Real-estate property management (and similar applications, such as car property management) - Data Science students might want to investigate available datasets about blockchain and the different cryptocurrencies (e.g. Bitcoin) - Surprise me !

The ethical hacking tool could perform one or more attack types, including attacks on TCP/IP and common networking protocols, websites, Windows, Android, Ubuntu and any other software/system. It also could use any technique, such as (D)DoS, injection (e.g., SQL), overflow (e.g., buffer and heap), etc. The tool could be for any purpose related to ethical hacking, including reconnaissance (e.g., identifying open ports and available services), deceiving end-users for all sorts of social engineering, building exploits and using them, maintaining access on a system (e.g., through backdoors, remote admin tools, steganography). It would be interesting to use AI to automate or improve the hacking tool in general. For example, an AI system could be used to automatically find vulnerabilities, generate obfuscated malware, or determine which attack to carry out depending on the target. I am also interested in upgrading existing tools with new capabilities; most of them are open source and available on github. Potential challenges (depend on the attack and target): parallelisation of the attack (e.g., port enumeration), training machine learning models, identifying vulnerabilities. Note: - Multiple students could work on different hacking tools in parallel. - Programming languages: C, Python, Ruby, assembly, ... (but not Java!) - The project's exact level on difficulty will depend on the agreed aim and objectives.

The objective of this project is produce a file synchronisation system based on BitTorrent. The system will provide functionalities for saving and retrieving files as well as synchronising them across the devices of files owners.

There are two types of certificates: X.509 and PGP. Public key certificates are used to identify users. Privilege certificates, on the other hand, are used to define access rights are privileges. X.509 PMI is an example implementation of privilege certificates. Privilege certificates can reliably be used in auhtorisation systems to grant/deny access to resources. Permis (https://en.wikipedia.org/wiki/PERMIS) is an example of authorisation system. Our objective is create an authorisation system. Implementation: Programming language: C, C++ or Python OS: Linux (Preferably CentOS), Unix. F21CN Computer Network Security (or equivalent course) is a pre-requisite for MSc students and co-requisite for Hons students.

This project builds on previous projects I supervised to use several ML techniques (mostly deep learning) to detection exoplanets.

Exoplanets are planets that orbit other stars. 3000+ exoplanets have been detected so far, and there are more to come! The most successful exoplanet detection technique so far (with 2000+ detected planets) is transit shape detection. This technique looks for drops in light intensity of a star when its planet comes between the star and earth observers. The challenge here is that there are 150K+ stars being observed and this is too many to be processed by humans. Machine learning can be applied to efficiently detect such drop in stars brightness without human intervention. This project builds on a previous MSc project done under my supervision in 2016/17.

To be discussed in a face-to-face meeting.

Several machine learning algorithms exist and can be used to, e.g. predict the value of an output based on inputs. The input is a matrix. Sparse matrices are matrices whose elements are mostly zeroes. Not taking that fact into account results in sub-optimal manipulation of the matrix and a waste of CPU time, RAM and storage. Our objective is to: - Build a library that implements one or more feature selection mechanisms - Implement one or more machine learning algorithms - (Optionally) parallelise computations. - (Optionally) integrate our library in R. Programming Language: - C, C++ - (Optionally) Assembly - Certainly not Java :) Some Wikipedia Reading: - Sparse matrices: https://en.wikipedia.org/wiki/Sparse_matrix - Feature selection: https://en.wikipedia.org/wiki/Feature_selection - Machine learning: https://en.wikipedia.org/wiki/Machine_learning The project can be taken a group of students where each of them will be working on a particular component of the API.

This project will review existing works for android malware detection. It will then investigate how to apply machine learning techniques to it. This will include identifying possible features that can characterise malware (e.g. subsets of binary code) then applying suitable techniques to them. The following books are in the library, you might want to have a look at them beforehand: - https://www.nostarch.com/malware, - https://www.nostarch.com/androidsecurity, - https://www.packtpub.com/big-data-and-business-intelligence/building-machine-learning-systems-python-second-edition

This project will review existing works for Linux malware detection. It will then investigate how to apply machine learning techniques to it. This will include identifying possible features that can characterise malware (e.g. subsets of binary code) then applying suitable techniques to them. The following books are in the library, you might want to have a look at them beforehand: - https://www.nostarch.com/malware, - https://www.packtpub.com/networking-and-servers/learning-linux-binary-analysis, - https://www.packtpub.com/big-data-and-business-intelligence/building-machine-learning-systems-python-second-edition

This project will review several existing machine learning-based malware analysis and critically appraise them. A comparative study would allow to draw conclusions on the suitability of the different techniques for malware analysis. The following books are in the library, you might want to have a look at them beforehand: - https://www.nostarch.com/malware, - https://www.packtpub.com/big-data-and-business-intelligence/building-machine-learning-systems-python-second-edition

The project will be about a dataset(s) of your choice (e.g. from your work, kaggle.com) with an objective to uncover hidden patterns in it. Specific details to be discussed.

Details to be discussed.

Reputation systems are used to assign, share and maintain a score to entities in a system. Those entities can be files or users for example. Reputation systems are common place, and can be found on commercial websites, such as souq.com or eBay; and in distributed systems such as BitTorrent. In the case of BitTorrent (or other P2P networks), scores can be assigned to either 1- Users: e.g. a score of 0 means, for example, the user shares malicious content (for security applications), or is a free-rider, i.e. someone who has a selfish behaviour (for QoS) 2- Files: e.g. a score of 0 means, for example, it contains malware (for security applications), or has a misleading title (for QoS). We have several published papers in the field and did supervise several projects on this topic that can be shared with interested students on demand.

Will provide required hardware. Details of the project to be discussed in a face-to-face meeting

Several topics can be done here. Just as an example, enable mobility of users, both at intra-house and inter-house levels. The location of the user inside the house would allow the system to adjust the house parameters to the user. For example, when the user moves from room 1 to room 2, i.e. intra-house movement, the music in room 1 is switched off, and it is switched on in room 1. When the user visits their neighbours, i.e. inter-house movement, non-confidential parts of their profile can be automatically uploaded to their destination to personalise environment parameters, e.g. A/C temperature (if the host policy allows it).

While existing communications tools such as Microsoft tools, Collaborate and Zoom can be used to carry-out Academic-related tasks such as teaching, supervision meetings and academic boards, they all present some limitations and/or constraints. These include price & license limitations, privacy issues and inability to personalise to local context. This project aims to create, from FOSS, an alternative to the above tools that can be used by academic institutions. Furthermore, Covid-19 has pushed several academic institutions, each with its IT infrastructure, to make a sudden move to online delivery and were struggling to find an adequate tool or at least a product they can customize by editing it. We will provide such tool. In addition to the obvious ability to establish audio and video calls, interesting features, that might require more than one student project, include: - Ability to share documents, whiteboard, entire screen with participants - Integration in organisation, e.g., active directory, Learning Management System (LMS) - Role management: presenters, attendees, moderators, breakout-manager, etc. - Creation and management of breakout rooms. - Integration in (open) calendar software. - Possibility for individual organizations to host their own instances of our software - Surprise me! By doing this project, you agree to the following: The software is to be released under the GNU Affero General Public License (https://www.gnu.org/licenses/agpl-3.0.html). Changes to the choice of the license must be agreed by Dr. Hani Ragab Hassen.

There are several cybersecurity challenges in robotics and we can work on one of them: Secure Communication: communication could be either with other robots (e.g., in a swarm scenario) or with controllers or base stations; compromising those communications can lead to disasters. Intrusion Detection Systems (IDS): since the traditional IDS are made for standard TCP/IP networks, expecting a different type of traffic. Developing suitable IDS using AI would add an excellent layer of protection. Data Privacy and Ethics: robots can get access to sensitive data, especially those used in medical context or personal assistance. It is crucial that this data is only accessible by authorised individuals and according to a pre-defined policy. AI and Machine Learning Security: many robots are controlled (partially or entirely) by AI systems. It is important to protect those systems against adversarial attacks that could manipulate the AI controller of a robot.

Socially Assistive Robots (SARs) represent a promising technology to provide assistance outside of clinical and controlled environments. In particular, their deployment in the house of prospective users can provide effective opportunities for early detection of Mild Cognitive Impairment, a condition of increasing impact in our ageing society, by means of digitalised cognitive tests. The aim of this project is to turn classical paper and pencil tests into SAR-based applications. The final outcome will be a ROS-based application that integrates a speech module, a graphical user interface and a dialogue manager.

In most of human-robot interaction experiments the robot is not fully autonomous. In these cases, the investigator becomes the puppeteer, or Wizard, and controls the robot without letting the participants of the experiment realise that the robot is merely remote controlled. The wizard can control all the functionalities of the robot or take over from the robot only in specific circumstances. This is usually done for safety reasons or because, when the variables under observation are all human-dependent, it is much more important that the experiment carries on without any interruption caused by a robotic malfunctioning. To be able to remote control the robot the wizard needs to have a full picture of what is happening in the experiment room in terms of flow of interaction between the robot and the participant, inner state of the robot, possible next action to take etc. The aim of the project will be to create a modular wizard interface, possibly integrating ROS, that could be easily used under different experimental conditions.

Contact me if you want to discuss a possible project on human-robot-interaction; trust in human-robot rapport; ethical implications of robotics and AI applications.

Adoption of robotics solution is still a challenging problem. This is driven by the fact that the general public is exposed to robots and their applications mainly through the media, that often times exaggerate the capabilities of the platforms. This is even more true with social robots, that are expected to be our companions and everyday helpers. What happens when robots fail? Most of the users get discouraged and dismiss the technology. This project will look at how the perceived gravity of the robot failure changes with respect to the level of knowledge about the robot’s capabilities. This will be tested with a user study. Within the project you will have to: 1) define the different levels of information to give to participants before the study begins; 2) develop a task for a social robot (platform to be decided as a part of the study design) to complete together with the participants; 2) program the robot to fail within the task 3) collect and analyse the data on participants perception of the robot following the interaction.

Trust is essential for successful human-human interactions and plays a major role in human-robot interactions, influencing the human’s willingness to accept information from a robot and to cooperate with it. Modelling trust could therefore be a vehicle to build more intelligent social robots. For this reason, much work has been done in trying to identify the factors defining trust and a computational model that could encapsulate the concept. Bayesian models and reinforcement learning have shown promises in this respect. Although trust evolves as the interaction evolves, in many works time is not fully taken into consideration. The objective of this project will be to dive into the literature on trust modelling to develop and test (through simulations) a cognitive architecture on the evolution of trust in human-robot interaction.

I have 20+ years experience in running and contributing to free/open source software projects. If you have an idea for a project in any area that will make a substantial code contribution to an existing FOSS project, I'd potentially be interested in supervising it - I can advise on FOSS licensing, working with a FOSS community, tools and techniques normally used in FOSS development, and so on.

I work on the ld-decode FOSS project, which captures high-quality digital video from analogue video sources such as LaserDisc and videotape. The ld-chroma-decoder tool is part of this: it extracts colour information from the video, converting the original "composite" signal into an RGB representation that can be shown on modern displays. This is a complex and computationally-expensive signal processing task. There are various ways ld-chroma-decoder could be improved: you could speed it up by making parts of it run on the GPU, or you could improve the PAL decoder by training it more effectively, or you could add support for the French SECAM video standard, or or or... there are more ideas on the ld-decode Wiki. I'd be interested in supervising anything related to this project; if working with analogue video sounds interesting to you then please talk to me.

Interactive fiction is one of the oldest genres of computer game. These days it includes text and graphic adventures, hypertext games, visual novel and other forms of game based on storytelling within a modelled world. You can build games from scratch in this genre (you might even have built a text adventure as a beginner's programming task at some point), but most creators use game engines such as Inform, Twine and RenPy. I'm interested in supervising projects that want to build or analyse this kind of game, or to work on tools for creators to use, or to resurrect classic games through emulation or reimplementation. Please talk to me if you'd like to work in this space.

Modern hard disks and SSDs corrupt data at a fairly predictable rate. Integrity-checking filesystems and software RAID schemes protect against this by using various checksumming approaches to detect corrupt blocks; if a corrupt block is detected, it must be obtained from another copy of the data. However, since the most common type of corruption is a single bit being flipped, it should also be possible to try to repair a corrupt block by flipping individual bits and seeing whether the checksum is correct. Implement and evaluate this scheme inside Linux software RAID or btrfs.

If you don't like folk music, this is not the project for you. MusicBrainz is an openly-licensed public database of metadata about recoirded music - it's used by the BBC, for example, to provide various kinds of information about music on their web site. I'd like it to have better metadata for traditional/folk music - for example, cross-referencing songs to catalogues such as the Roud catalogue (songs) or thesession.org (tunes). Some of this information has been added manually, but you should be able to identify likely recordings of particular pieces based on their names and performers... and perhaps based on audio fingerprinting?

"Ugly names" for TLS web sites. As an alternative to traditional CA infrastructure, encode cryptographic identifiers in DNS names as a mechanism for verifying certificates. This is how Tor hidden services work already - you end up with a long, awkward name, but you are no longer dependent on a fragile, expensive (and often corrupt/fraudulent) certificate authority. Implement this in OpenSSL or Firefox.

Programming in modern C++ is made considerably safer by the existence of smart pointer classes such as std::shared_ptr; in most cases, these can be used as drop-in replacements for C-style pointers, avoiding many of the security and correctness faults common with pointer use. However, these are library features - there's no affordance in the language to make using them more convenient. Add support to a C++ compiler for a more convenient syntax for smart pointers, like the existing syntaxes for C-style pointers (*) and C++ references (&). For example, you might allow a shared_ptr argument to be written as "Foo% ptr". You'd need to design an appropriate syntax, modify a compiler to understand it, and evaluate whether it measurably simplifies real-world code.

In a typical filesystem, the contents of the disk depends not just on the files being stored, but other factors such as the order they were written in, previously-deleted files, the size of the disk, and so on. This makes forensic analysis of disk images possible - you can extract deleted files, or tell information about how the filesystem was built. Instead, I'm proposing that for any given collection of files, there should be exactly one valid representation of them on disk - guaranteeing that no information is being accidentally leaked. This in itself is not particularly difficult, but the challenge comes in making it efficient to update later on...

The Git version control system is widely used, and has been extended over the years to serve various purposes - for example, it's possible to cryptographically sign a commit. It would be useful to be able to encrypt some files within a repository - e.g. if you have files containing secret keys within a project that only some contributors should have access to. You could draw ideas for this from the Git-LFS large file extension, and from encryption extensions in Linux filesystems.

Given a genealogical database from a system like GRAMPS, generate a high-quality vector-graphics family tree rendering - not just ancestors or descendants of a single person, but using a constraints system to represent as much of the tree as possible in a single rendering. This is something I've prototyped before and have some ideas about, but needs redoing properly using modern graphics technologies. I can provide sample data.

I work on the ld-decode FOSS project, which produces high-quality digital captures of analogue video sources (such as LaserDisc or videotape). It's fairly common to find examples of video where faults in the original source are visible - for example, the red/green/blue sensors in the camera are misaligned, or the image is disturbed by loud noises near the camera (microphony), or the original video was played back on a misaligned video recorder so lines are offset. These show up in commercially-released video as well. Given an understanding of the structure of the video signal, it should be possible to correct for these kinds of faults in software to substantially improve picture quality.

The modern GPU is a high-powered general-purpose computer system, with large quantities of memory and the ability to access parts of the CPU memory space. On APU systems, it can potentially access hardware devices too. Investigate what malicious software running on the GPU might be capable of. I'd be particularly interested in the implications for APU system - can you do stealth network communication from the GPU, for example?

A modern GPU is a highly capable, multicore, general-purpose computer system, that just happens to be particularly good at vector arithmetic. But they're generally used for graphics or for offloading maths-intensive tasks from the main CPU. What would a proper operating system designed to take advantage of a GPU's architecture look like? There's plenty of existing work in operating systems consisting of communicating parallel tasks - you could look at microkernel systems like Minix, or OSs for loosely-coupled parallel architectures like HeliOS. See what you can do to enable efficient, secure (if possible!) general-purpose computing on the GPU.

If you don't like folk music, this is probably not the project for you. Thousands of folk tunes (short instrumental pieces), from many different traditions, are available in easily machine-readable ABC format in online databases like thesession.org and folktunefinder.com. As folk tune authors tend to "borrow" elements of existing tunes, it should be possible to take a collection like this and identify common elements between tunes - for example, showing how a tune has moved between different traditions (e.g. Scotland/Ireland/US) and been adapted to different instruments, or how different versions of the same tune have diverged over time. You could potentially use this to build a tool for exploring a collection of tunes, by showing links between tunes that share elements of melody.

Harold Abelson's Dazzle Dart (https://dl.acm.org/doi/10.1145/1216479.1216482) was one of the earliest multiplayer video games, created at MIT in the early 1970s. It's well overdue for a remake using a modern engine! The original was constrained by the hardware it ran on and had a very abstract 2D display; you'd need to think about whether to adapt it to 3D and how to take advantage of modern controls. (A previous student did a basic 3D version using Unity, which worked pretty well, but I'd like to see a more polished version.)

The Linux kernel, like Linux userspace, takes advantage of address space layout randomisation (ASLR) to make it harder for an attacker to predict memory addresses within the kernel. But we could go further than this with some help from the compiler - you could also randomise the layout of the stack frame, the layout of structs in the kernel, and so on. This would mean compiling a new kernel each time you upgrade the kernel (or even each time you reboot), but that may be a price worth paying - and Fabrice Bellard's tccboot project showed that this can be done with relatively low overhead.

NFS is the standard network filesystem on Unix-like systems. Traditionally it's unencrypted, relying on the security of the network; it can be run over Kerberos, but that's complex, difficult to set up in small networks, and does not support modern cryptography. The Linux kernel now has good built-in support for TLS and other modern cryptographic primitives; in particular, the Wireguard VPN system uses a protocol based on the Noise framework. In this project, you would add support to Linux for running NFS over a TLS or NoiseSocket transport, making it easy to set up secure network filesystems.

The sudo tool is sadly nearly ubiquitous on modern Linux systems - sadly, because it has a long and inglorious history of appallingly bad security holes, through being written in C and doing a complex, security-critical job. Find ways to improve this! You might look at re-engineering it in a more secure language (or language subset), or redesigning it to take advantage of privilege separation or operating system sandboxing, or...?

The X11 graphics system has been widely used on Unix-like operating systems since the 1980s. It was originally designed to be resolution-independent, supporting high-DPI output devices such as printers in addition to regular displays. However, if you try using it on a high-DPI display these days, you will find that some of the libraries and server behaviour make assumptions about display resolution that are not appropriate for a modern 200+ DPI display (e.g. requiring low-resolution fonts or not computing spacing correctly in GUI layouts). As a result, people resort to ugly, inefficient Windows-style hacks such as pixel scaling - rather than using the display at its native resolution. Fix this - disable pixel scaling, configure X to run at the native DPI of a modern 4k display, try a range of applications and work out what's broken.

BPF is a virtual machine architecture that is used for various "programmability" tasks inside the Linux kernel - for example, you can use it to specify custom firewall rules or custom scheduling conditions. It's important that BPF is *not* a general-purpose architecture, since BPF programs must execute within a fixed amount of time and resources - the BPF verifier is responsible for checking BPF programs to make sure they meet these rules. Since the BPF verifier is just a bit of code written in C, it's had several bugs where harmful BPF programs are incorrectly validated. This seems like an ideal application for some formal reasoning - can you come up with a way of making the BPF verifier itself verifiably safe, so you can prove that it can't validate an unsafe program? I'm imagining using model-checking techniques for this, but I'm sure there are other ways you could attack this problem as well.

A musical project - 1980s drum machines like the Roland TR-808 and TR-909 are still widely used and cloned today, both in hardware and software. Software implementations are often based on samples, though, rather than on a physical simulation of the circuitry - making for less variation and flexibility. In this project, you'd use an existing FOSS electronics simulation system to build a model of a drum machine (or some parts of it), and wrap it in a LV2 software synthesiser so it could be played within a digital audio workstation such as Ardour.

A process calculus is a mathematical model of the behaviour of a concurrent program. Designing a programming language's facilities to correspond to a particular process calculus is interesting because it allows you to reason mathematically about the behaviour of programs written in that language - for example, proving that they can't deadlock or livelock. The Communication Sequential Processes calculus has been particularly successful, with languages like occam, Go and Rust using it as the basis of their concurrency facilities. But CSP dates from the 1970s, and there have been advances in process calculi since then! Philip Wadler's Classical Processes (CP) calculus is a particularly interesting example - it makes use of ideas from the theory of session types, which has traditionally been used to reason about the safety of things like network protocols and cryptographic procedures. It would be interesting to experiment with designing and implementating a simple programming language based on CP, in the same way occam is based on CSP.

Ransomware-resistant filesystem or storage device. Revisit the ideas behind log-structured filesystems in order to maintain the filesystem so that it can always be rolled back to previous states. This could even be done at the physical device level (e.g. build a device that filters SATA commands), so you can't actually destroy anything permanently without physical intervention. Implement this, either within the Linux kernel or as a prototype in userspace. (A previous student did the latter, so I'd rather see a real implementation.)

Radare is a suite of tools for reverse-engineering software - for example, automatically extracting a structured disassembly from a binary. It supports a range of modern architectures, but it would also be useful to apply it to code used on historical computer architectures - for example, when understanding the code as part of a computing history project, or when porting it to a new platform. I'd be particularly interested in support for the DEC PDP-10 architecture (a 36-bit architecture commonly used in the 1970s), but other architecture - e.g. various IBM mainframes - would also be interesting.

Jamulus is a FOSS system that allows musicians (like me) to play together in real time over the Internet. It has good support for high-quality audio, but it doesn't support video, so many groups that meet on Jamulus also have to use a separate video conferencing system such as Zoom or Jitsi to see each other. Add support for simple video conferencing to Jamulus. Since the Jamulus protocol is highly latency-sensitive, I suspect this would be best done by integrating a separate video-conferencing protocol into the Jamulus client (ideally an existing one for interoperability). There are some pretty substantial privacy concerns around this so it would make an interesting project in terms of security usability engineering.

RISC-V is a modern RISC architecture based on open-source principles; there's a core of instructions and a collection of extensions that provide additional facilities (e.g. vector maths). There are existing high-quality toolchains and software emulators for it - you don't need RISC-V hardware to work with it. Projects like CHERI have experimented with extending existing computer architectures to provide better security facilities - CHERI adds pointer bounds to the ARMv8 architecture. Design an extension to RISC-V to provide similar facilities, or to improve software security in other ways (e.g. bounds checking, pointer authentication, untrusted data tracking...). Implement this in an emulator to demonstrate that it can be used to detect errors in programs.

Some programming languages - notably Javascript - use a floating-point representation for all numbers. This is likely to cause bugs because floating-point numbers break many common assumptions about how numbers work. Investigate whether there are specifically any security implications of this - for example, do Javascript programmers introduce security bugs when doing array indexing or cryptography using floating-point numbers?

There are plenty of silly "XYZ simulator" games out there - how about one that simulates the staff of a busy 1960s/1970s TV studio? You could play as a camera operator, vision mixer, producer, boom operator, etc., or play together in multiplayer mode as a team of people trying to make a complex drama or news show work. Disasters would include broken equipment, misbehaving actors, unreasonable time pressure and invasions by visiting schoolchildren. For inspiration, have a look at the ADAPT project (https://www.adapttvhistory.org.uk/) or the stories on the BBC Tech Ops site (http://www.tech-ops.co.uk/next/).

Coverage-directed fuzzing is a highly effective technique for testing software - it combines random input with feedback from software coverage measurement to generate input that explores all the possible paths of execution through a piece of software. Apply this technique to a story-based game - I was thinking interactive fiction games such as those written in Inform, but you could also do it with other kinds of games - to ensure that all the possible routes through a game world are explored automatically during testing. A variant of this would be to take an arbitrary interactive fiction game and attempt to automatically generate a walkthrough for it.

Coverage-directed fuzzing is a highly effective technique for testing software - it combines random input with feedback from software coverage measurement to generate input that explores all the possible paths of execution through a piece of software. An emulator such as qemu, simh or MAME executes software written for a different architecture by simulating the CPU and peripherals in software. Faults in emulation are common - either producing incorrect results, or worse, producing security holes. However, if you have two emulators for a given architecture - or an emulator and a real CPU - then you could detect faults by using fuzzing to generate code, running it on both, and comparing the results; if they don't match, or the emulator crashes, you've found a problem. I would suggest picking a simple, common architecture with lots of different emulators available (Z80, 6502...) to maximise the chance of finding an interesting problem.

The X graphics system is widely used on Unix-like systems; its successor, Wayland, is starting to come into wide usage. Both of these have existing good-quality implementations that are written in C, and thus suffer from the usual security problems of unsafe languages. Implement a new X or Wayland server using a modern, safe programming language such as Rust or OCaml (I'm not interested in doing this with Java or C#). Alternatively, take one of the existing implementations and find a way of making it safe - for example by adding annotations to the C code to allow better safety analysis.

African e-commerce users are expected to surpass half a billion by 2025, a record 40% landmark compared to about 140 million users in 2017 (13%), representing nearly 17% compound annual growth rate. Additionally, Africa leads mobile internet usage with over 13% above global average, as well as nearly 5% more than Asian mobile usage. This indicated a clear indispensability and promising value for mobile approach to online businesses targeting African markets. However, African ecommerce is far from maturity in terms of profitability, as recent reports showed less than 30% of e-commerce start-ups were profitable in the continent, while most of the bigger companies are yet to record a profit in more than a decade. Meanwhile various studies have identified challenges that include underdeveloped infrastructure, logistical constraints and limited payment gateways. This project would study the influencing factors for the successes and challenges affecting e-commerce development in Africa, building regression models of e-commerce development and its turnover index as the contribution to the national GDP. Resultant models would be validated on relevant time series data, while Business intelligence tools including Google Analytics software, to be employed for preliminary investigations on the leading African e-commerce platforms. To drive insight and potentially to provide suggestions on how to advance e-commerce, machine learning toolkit – weka and SPSS software package would be utilized for modelling and statistical analysis of the data.

The benefits of generative artificial intelligence can be extended beyond text-based content creation and artistic personalisation into new realms of marketing and branding. This project explores new ideas of how visual content can be generated effectively using brand-centric visual prompts. Newly-generated material can be guided by visual branding elements such as logos, and typography, or by style transfer involving brand-based patterns, colors, and more. The aim of this project is to realise these ideas into a feasible framework, demonstrable by a software application (of any platform). The output of the software can be evaluated by trained media designers and lay users, to underscore its acceptance and practicalities.

In today's era of smart infrastructure, this innovative solution harnesses the power of edge computing and deep machine learning to revolutionize pothole detection. By deploying edge devices equipped with cameras on vehicles, road conditions can be monitored by moving vehicles, offering broader coverage compared to stationary installations. The use of deep learning algorithms, when integrated into these edge devices, can help analyse the imagery (from video stream) to detect potholes. Location information can also be used to precisely locate these potholes, and have reports sent to relevant stakeholders/authorities. Models for detecting road potholes (or road damage) from images can be trained with widely available data (see examples from https://sites.google.com/view/pothole-600/dataset and https://www.kaggle.com/datasets/rajdalsaniya/pothole-detection-dataset). The aim of this project is to implement an application for collaborative detection of road potholes from an edge device (e.g. smartphone) that is mounted facing the front view of a vehicle.

Healthcare is one of the notable industries that has been influenced by the Fourth Industrial Revolution and Healthcare 4.0 is a term that has emerged to resemble this revolution. Healthcare 4.0 is a collective term for data driven digital health technologies such as smart health, mobile health, wireless health, eHealth, online health, medical IT, telehealth/telemedicine, digital medicine, health informatics, pervasive health, and health information system. The revolution in the healthcare industry is already underway, yet, because of the conservative and slower pace of technological adoption by healthcare insiders, as compared to other industries, digitalization in this sector has not been so evident (Pace et al., 2018; Manogaran et al., 2017). Multiple projects can be done in this space. Please get back to me for further discussion.

To be discussed

Biometric authentication is simply the process of verifying your identity using your measurements or other unique characteristics of your body, then logging you in a service, an app, a device and so on. The human machine interface (HMI) is a main communication method between human and computer. Through current HMI, a machine receives and accurately responds to the commands instructed by the users. In the next generation of HMI, machines will be required to deal with more challenging problems/decisions (such as affective evaluations, ethical quandaries, and other innovations) in a self-governing manner. We can use Galvanic intrabody communication to transfer data through the human body.

Details to be discussed with the student.

Artificial emotional intelligence or Emotion AI is also known as emotion recognition or emotion detection technology. Humans use a lot of non-verbal cues, such as facial expressions, gesture, body language and tone of voice, to communicate their emotions. The vision is to develop Emotion AI that can detect emotion just the way humans do, from multiple channels.

TO BE DISCUSSED

Software plays an important role in battery life. The OS, firmware, drivers, and all small components are typically optimized to give better performance and energy efficiency. As the notebook PC (and smaller form factor devices, including tablets and smart phones) become pervasive compute platforms, battery life is becoming increasingly important, particularly with regard to standby or idle time. In addition, as hardware power states become more sensitive, software must be well behaved at idle so it doesn’t needlessly wake components, which would limit battery life. Several case studies presented here show how software “idle” behavior can have a negative impact in this area on Window -based systems.

Software can influence the energy efficiency of hardware significantly, since all hardware is controlled by software.

To be Discussed with the Student.

Being able to detect and recognize human activities is essential for several applications, including smart homes and personal assistive robotics. We perform detection and recognition of unstructured human activity in unstructured environments. There are many different ways this can be We use a RGBD sensor (Microsoft Kinect) as the input sensor or Radio Wave(WIFI) and compute a set of features based on human pose and motion, as well as based on image and point-cloud information.

With the rapid advance of sophisticated control algorithms, the capabilities of drones to stabilise, fly and manoeuvre autonomously have dramatically improved, enabling us to pay greater attention to entire missions and the interaction of a drone with humans and with its environment during the course of such a mission. I would be intrested to consider a project dealing with drones.For further discussions please do get in touch with me.

To be discussed

a suggestion system which selects the devices required based on the needs of the user, provides the price,possible network maps etc.

This project aims to use machine learning techniques such as ensemble learning, convolutional neural networks etc. to predict spot prices for a variety of industries. Machine learning is increasingly used in finance to make predictions as well as to aggregate among existing strategies for making investments over time. We will use various free as well as proprietary data sets to assess the value of our newly developed methods in terms of both profit and risk, and compare them with state of the art techniques. This will also involve developing new “lucky factors” (features) that can be extracted from the data to inform and improve existing and new investment strategies. The expectation is that the work will lead to a conference publication.

Description to be added later.

I am intrested in Computer Vision projects that could be used for applications like Object identification with Semantic Analysis in real time, Self Driving Cars, Spatial Data Analysis etc.

I am interested in any robotics-based projects or application like:- Self Driving Cars Drones Navigation Robot mapping Robot Interactions Please get in touch with me if you need to discuss on any of these topics.

Generating photo-realistic images from text is an important problem and has tremendous applications, including photo-editing, computer-aided design, etc. More details to be discussed with the student

There has been a growing interest to build the smart indoor environment solution such as smart home or office, which is capable of sensing and responding to the users using WIFI signals only. In this project, i would like to investigate the use of WIFI for robust authentication of the user in different situations.

To create an student attendance monitoring system that would use Face recognition as one of its major features.

TO be discussed

To be discussed with the student

Algebraic effects and their handlers are a modern approach to structuring computational effects of programs, including interaction with outside world, but also effects internal to the program. In addition to various libraries that provide the programmer with an ability to use algebraic effects, several experimental programming languages, including Helium (https://bitbucket.org/pl-uwr/helium/src/master/), Frank (https://github.com/frank-lang), Koka (https://koka-lang.github.io/koka/doc/book.html), etc. have been recently developed. These can be used as a means to study the impact of the new programming idiom on software development. This project aims to study the impact of programming with algebraic languages on parsing technology. It would require the student to a) investigate the programming idiom to be used, b) investigate parsing techniques, and decide on a family of techniques suited to implementation using algebraic effects, c) build a tool/library for a chosen language that uses algebraic effects to provide support for parsing. The prerequisites for this project include background in functional programming and strong interest in cutting-edge language technology in this area, as well as a background in language technology that would allow the student to efficiently review and adapt approaches to parsing (around the level given by the Language Processors course). Understanding of formal semantics of programming languages is not strictly necessary, but even limited exposure may be helpful in understanding the research papers that will need to be studied.

According to the World Health Organisation (WHO), cardiovascular diseases cause around 17.9 million deaths every year, due to an increasing number of heart attacks and strokes. Therefore, this study aims to utilize data science and machine learning techniques to explore the relationships among contributing factors that may have a bearing on the risk of suffering from heart disease. It aims to accurately predict whether a patient is likely to suffer from heart disease based on based on existing health public datasets.

Industrial and manufacturing are two of the most high-risk sectors for workers. According to the U.S. Bureau of Labor Statistics, there were 2.8 million nonfatal workplace injuries and illnesses in 2019. This includes over 400,000 nonfatal injuries and illnesses in the manufacturing sector. Safety is of paramount concern for both employees and employers at any workplace, and the wearing of Personal Protective Equipment (PPE) like helmets, gloves, masks, vests, etc., by workers is a cornerstone of workplace safety. By analyzing images/videos, the project will explore how computer vision can be used to create safer workplaces by ensuring PPE compliance and detecting any violations in real-time.

According to a new report from a project carried out by Harvard Graduate School of Education, young adults in the U.S. report twice the rates of anxiety and depression as teens. The report identifies a variety of stressors that may be driving young adults’ high rates of anxiety and depression. The proposed project can utilize a mixed-methods approach, including surveys, focus groups, and interviews, and use of machine learning and data science tools to predict or visualize patterns in young people's perceptions and experiences surrounding their mental health.

The accelerating convergence of artificial intelligence (AI) and the Internet of Things (IoT) has sparked a recent wave of interest in Artificial Intelligence of Things (AIoT). At this point, most of society understands the issue of air pollution and its repercussions not only on the climate but human health as well. However, not many of us seem to realise that indoor air quality is as important. Unfortunately, indoor air is also susceptible to pollution, and as studies show, its presence can be up to 8 times higher than in outdoor air and most people spend around 80 to 90% of their time indoors. By analysing historical data sets, physical, chemical and biological characteristics of indoor air, different models can be evaluated to predict Indoor Air Quality.

To study/design systems for healthcare analytics. Example areas can be smart homes, Electronic health records.

To create interactive extended reality (AR, VR) applications. Can investigate the use of volumetric videos and other alternative 360 degrees video capture to create interactive extended reality applications.

To investigate security and privacy of IoT networks in smart homes environment.

Applications of multimedia security. Extracting features and artefacts from multimedia for forensic analysis.

Are you interested in the intersection of machine learning, mathematics, and verification? Do you want to explore how machine learning models and proof assistants can be combined to automatically translate natural language mathematics into formal specifications? Then this honours thesis project is for you! In this project, you will work on testing how well LLMs perform on autoformalization, i.e. translating natural language mathematics into formal language. You will explore the capabilities and limitations, as well as evaluate its performance in comparison to existing methods for autoformalization. You will also have the opportunity to learn about proof assistants and their role in formal verification. If you are interested in this project, please contact me at [k.stark@hw.ac.uk](mailto:k.stark@hw.ac.uk) or make a short appointment at https://outlook.office365.com/owa/calendar/KathrinsMeetingCalendar@heriotwatt.onmicrosoft.com/bookings/.

The goal of this project is to develop a base solution, and then iteratively improve on this solution while reasoning on the soundness of the improved solution. See for example https://www.cs.tufts.edu/~nr/cs257/archive/richard-bird/sudoku.pdf for a solution of Sudoku in Haskell. I have some ideas, but you are very welcome to bring your own ideas. If you are interested in this project or would like to discuss your own project ideas, please contact me at [k.stark@hw.ac.uk](mailto:k.stark@hw.ac.uk) or make a short appointment at https://outlook.office365.com/owa/calendar/KathrinsMeetingCalendar@heriotwatt.onmicrosoft.com/bookings/.

From security protocols used in online banking, over embedded control systems, to e-mail and disk encryption: every day, we use software we rely on to be safe and secure. Many things can go wrong: there might be bugs in the program itself or the compiler can produce wrong machine code. Formal verification of a program allows us to prove indisputably – using only a small set of assumptions and deduction rules – that all inputs lead to the desired behaviour. This guarantee is particularly important if faulty software would lead to a significant loss or if the software has to withstand a determined attacker. For realistic programs, verifying rich specifications beyond shallow properties such as no out-of-bound array subscripts in a fully automated way is challenging due to the immense search space. Interactive proof assistants such as Coq or Isabelle allow humans to fill in where fully automated methods fail by allowing such proofs to be developed in an interaction between humans and computers. For this reason, proof assistants have recently gained importance also in industrial applications and are used by companies like Microsoft, Amazon, Apple, and Google. I'm looking for students who are interested in learning about the verification of programs. I also have ideas of variable difficulty from current research projects. Let's talk! If you are interested in this project or would like to discuss your own project ideas, please contact me at [k.stark@hw.ac.uk](mailto:k.stark@hw.ac.uk) or make a short appointment at https://outlook.office365.com/owa/calendar/KathrinsMeetingCalendar@heriotwatt.onmicrosoft.com/bookings/.

Are you interested in compilers and programming languages? Do you want to extend your knowledge in OCaml and optimize a compiler for a real course project? Then this honours thesis project is for you! In this project, you will work on extending the existing OCaml compiler for the F29LP course with several optimizations, such as live variable analysis and dead code removal. You will learn about compiler design and implementation, as well as gain experience with OCaml programming. Your work will involve researching and implementing the optimizations in the compiler, evaluating their effectiveness, and documenting your findings. If you are interested in this project, please contact me at [k.stark@hw.ac.uk](mailto:k.stark@hw.ac.uk) or make a short appointment at https://outlook.office365.com/owa/calendar/KathrinsMeetingCalendar@heriotwatt.onmicrosoft.com/bookings/.

Compiler optimization is the process of improving the performance of a compiler-generated code by applying a series of transformations to the code. For realistic programs, verifying rich specifications beyond shallow properties such as no out-of-bound array subscripts in a fully automated way is challenging due to the immense search space. Interactive proof assistants such as Coq or Isabelle allow humans to fill in where fully automated methods fail by allowing such proofs to be developed in an interaction between humans and computers. For this reason, proof assistants have recently gained importance also in industrial applications and are used by companies like Microsoft, Amazon, Apple, and Google. In this project, you will work on proving the correctness of optimization steps in a compiler using the Coq proof assistant. Your work will involve implementing and verifiy the optimization steps in the proof assistant, formalizing their correctness proofs, and documenting your findings. If you are interested in this project or would like to discuss your own project ideas, please contact me at [k.stark@hw.ac.uk](mailto:k.stark@hw.ac.uk) or make a short appointment at https://outlook.office365.com/owa/calendar/KathrinsMeetingCalendar@heriotwatt.onmicrosoft.com/bookings/.

In this project, you will work on writing a lexer generator in a programming language of your choice. Lexer generators are tools that automatically generate the lexical analyzer component of a compiler based on a set of regular expressions. You will learn about compiler design and implementation, as well as gain experience with programming language theory and lexing. Your work will involve researching and implementing the lexer generator, evaluating its effectiveness, and documenting your findings. You will also have the opportunity to explore different programming languages and lexing techniques. If you are interested in this project or would like to discuss your own project ideas, please contact me at [k.stark@hw.ac.uk](mailto:k.stark@hw.ac.uk) or make a short appointment at https://outlook.office365.com/owa/calendar/KathrinsMeetingCalendar@heriotwatt.onmicrosoft.com/bookings/.

If you have a project idea around compilers/F29LP, I am happy to meet and discuss it. I also have several ideas for suitable projects. Let's talk! Feel free to contact me at k.stark@hw.ac.uk or make a short appointment at https://outlook.office365.com/owa/calendar/KathrinsMeetingCalendar@heriotwatt.onmicrosoft.com/bookings/ so that we can discuss a possible project together. ###

If you have a project idea around functional programming, I am happy to meet and discuss it. I also have several ideas for suitable projects. Let's talk! If you are interested in this project please contact me at [k.stark@hw.ac.uk](mailto:k.stark@hw.ac.uk) or make a short appointment at https://outlook.office365.com/owa/calendar/KathrinsMeetingCalendar@heriotwatt.onmicrosoft.com/bookings/.

I'm happy to supervise any student in a master class on any of the above topics. There are many topics available; talk to me if you have an idea or are just interested in one of the topics.

Dataflow languages are commonly used to program embedded systems such as Field Programmable Gate Arrays (FPGAs). Static dataflow models ease reasoning and compile-time scheduling, however their lack of expressivity constrains the programmer's ability to implement complex algorithms. Various approaches have been taken to 1) identify and 2) reason about static dataflow properties of dataflow programs, including static analysis and model checking. This project will take a new approach, which is to implement a static dataflow embedded domain specific language (DSL) in the dependently typed Idris language. This approach will use Idris's type checker to prove static properties of dataflow actors, and will infer data rates and ideal scheduling policies for compilation to FPGAs. A possible implementation plan for the project is: 1) Developing the dataflow EDSL in Idris. 2) Developing scheduling policies within the types of the EDSL. 3) A Verilog backend of the EDSL to target FPGAs.

A recent paper shows that adding prefetching to the implementation of operations over data structures (i.e. container libraries) can yield a significant speedup by hiding the latency of memory access. Here's the paper: "Prefetching in Functional Languages", ISMM 2020. https://www.cl.cam.ac.uk/~tmj32/papers/docs/ainsworth20-ismm.pdf That work was done in the context of the language OCaml. This project will investigate whether adding prefetching to Haskell libraries like the `containers` library can yield speedups in the same way. An additional dimension in the design space for Haskell is its lazy evaluation semantics, which might mean that prefetching benefits are even more significant for Haskell than they are for OCaml. This project will find out.

Haskell is an almost unique language, in the sense that it has lazy-by-default evaluation semantics and it is a pure language (no side effects). Laziness poses challenges for reasoning about memory performance and memory access behaviours. Recent tooling developments have enabled more precise memory profiling of Haskell code: https://well-typed.com/blog/2024/01/ghc-eras-profiling/ This project would evaluate the usefulness of these new tools, and look to extend them by integrating their reports into IDEs for source-code annotations.

"AI at the edge" allows autonomous devices and smart sensors to perform tasks such as object detection, classification, speech recognition and complex text processing tasks -- in real time and with very low power requirements. This project will compare the performance and usability of two neural network accelerator devices: The a Google TPU on a Coral.AI USB, and an Intel Neural Compute stick USB. If the student wishes to go further, a third comparator would be programming a neural network into hardware fabric with an FPGA.

For executing deep learning algorithms based on neural networks, there is a shift expensive (finance and energy) centralised GPUs to Edge Computing devices such as embedded CPUs and programmable hardware (Field Programmable Gate Arrays, FPGAs). Trained neural networks require hundred of Megabytes or memory, and high computation resources. Emerging compression techniques are able to reduce those resource costs significantly. However, this also affects the accuracy of neural networks. This project will explore industry driven frameworks e.g. Xilinx's Python FINN framework and Intel's Distiller framework, to assess the speed, accuracy and resource use performance metrics for across a set of neural network models. The outcomes of the project will inform users of neural networks and of embedded processors on how best to construct and refine deep learning models for application domains such as remote image processing smart cameras, autonomous robot, and driverless vehicles.

The performance of functional programming language implementations until 15 years ago relied on increasing CPU clock frequencies. The last decade has seen the rise of the multi-core era to overcome this stall. Due to a single connection from multiple cores on a CPU to main memory, general software implementations of parallel programming languages are finding the limits of CPU architectures due to the Von Neumann bottleneck. In very recent times, the fabric on which we compute has changed fundamentally. Driven by the needs of AI, Big Data and energy efficiency, industry is moving away from general purpose CPUs to efficient special purpose hardware e.g. Google's Tensorflow Processing Unit (TPU) in 2016, Huawei's Neural Processing Unit (NPU) in smartphones, and Graphcore's Intelligent Processing Unit (IPU) in 2017. This reflects a wider shift to special purpose hardware to improve execution efficiency. This BSc project will explore alternative approaches to implementing functional languages, by offloading runtime system components onto dedicated FPGA-based hardware implementation. For example special purpose memory hierarchies to minimise memory traffic, prefetching in hardware, or garbage collection in hardware to reclaim memory with minimal latency. The project will work alongside the EPSRC HAFLANG project ( https://haflang.github.io ), where the aim is to develop a processor architecture for managed functional languages to significantly outperform the runtime and energy performance of CPUs. The student would be working alongside the HAFLANG project's postdoc researcher on this project, with frequent meetings with Rob Stewart.

Programmable hardware is increasingly used in many application areas, including Internet of Things and Smart devices, as well as safety critical systems. The correctness of hardware designs is therefore essential. When two hardware components communicate, they must do so via an agreed protocol. An example is the widely used AXI protocol. Many hardware designs are not open source, meaning you can use the generated IP hardware block from a vendor, but cannot verify its implementation by inspecting the hardware description code. How are you to trust a piece of hardware? So instead, one must inspect its communication behaviours to have confidence in its correctness. There is a tool called 'mbac', which generates hardware blocks from temporal properties that describe protocol rules. You can synthesise the generated hardware, meaning you can deploy it alongside closed source IP blocks, and it flags any time these properties are violated. This project will evaluate the mbac tool in terms of its usefulness for widely used protocol standards, its scalability to complex protocols, its effectiveness in catching hardware bugs, and potential practical deployment scenarios to make users aware of hardware bugs.

The Haskell functional language is based on lazy evaluation where computation is not performed until their values are required. This has many formal and pragmatic advantages over the more common strict evaluation but carry some runtime overhead. This project will involve systematically profiling lazy, strict and lazy/strict hybrid Haskell benchmark implementations to expose the strengths and weaknesses of Haskell's non-strict evaluation.

Type providers is an idea in programming languages research, whereby an external data source such as a CSV file is used to generating programming constructs. Typically these components are types (i.e. Java classes, or types in functional languages), but can also be properties or even functions or methods. In the semantic web world, the goal is to provide as much meaning to data as possible. In other words, what is the semantic meaning of an entity from a particular domain, and what is relationship between entities in that domain. This project will investigate whether there is a deep connection between how domains are captured using ontologies from the semantic web, and type systems for functional languages. The student on this project may wish to explore building type providers in their favourite functional language. As a starting point, with support for RDF data to convert ontology schema into types of that programming language. For a richer investigation, the project will explore how ontological rules can be mapped to types and constraints in the target programming language. This project may raise some interesting questions: if type constraints derived from ontology rules are sufficiently strong, can we perform ontology reasoning to check RDF semantic web data is sound and consistent? Can we do this at compile time type provider OWL/schema data sources and RDF data sources? On the practical side of this work, take a look at RDF type providers for the F# language available in the Iride library: https://github.com/giacomociti/iride That may be a starting point for any implementation work.

Stream processing is about doing one-pass execution of continuous queries over a potentially infinite stream of values. Streams come with different characteristics, e.g. data rate from low (one or two values an hour) to high (thousands of values a second), and is published either in steady stream or in highly irregular bursts. Many use cases require joining values across streams and stored sources, as well as computing aggregation functions. To support these operations over potentially infinite streams, windowing operators are used to provide a scope for the operation. Additionally with RDF streams, there is also the possibility of performing inferencing over the stream of values, i.e. generating new data based on the content of the stream. All these needs pose interesting challenges for stream processing: how much data needs to be windowed to fire inference rules? And crucially, what processing hardware should be used to support throughput of thousands of RDF data items a second? Field Programmable Gate Arrays (FPGAs) are programmable hardware chips, which when configured have a circuit that is precisely design to meet an algorithmic need. For streaming domains they offer extremely high throughput, and use very little energy. This project will investigate the use of FPGAs for developing special purpose a RDF stream processor. A key hardware design decision will be to decide how "programmable" the hardware is at runtime. In other words should the hardware design allow runtime FPGA programming to (1) switch window operators, (2) change the window size, (3) upload new inference rules. A desirable artefact from this project will be an open source hardware design for a RDF stream processing hardware accelerator.

Dataflow languages are good models for programming embedded and configurable hardware architectures, because the distributed memory model maps well to these architectures. There's a wide variety of dataflow models, from static dataflow all the way to dynamic dataflow. Static models are easier to reason about e.g. how much data can be processed, but these programming models are restrictive. Dynamic models can express complex algorithms but reasoning about runtime behaviour is much harder. This exposes a sweet spot: can we expose moderately expressive programming models without losing all ability to reason about performance, or to generate efficient hardware. This project will explore the idea of abstracting properties of dataflow programs, to compute what the throughput performance capabilities of such programs is, without needing to run them. The technology to integrate could be (1) HoCL for programming, (2) Kiter to determine throughput performance and (2) PREESM to turn programs into executables. Possibly also using DIF as an interchangeable dataflow model format. https://github.com/jserot/hocl/ https://github.com/bbodin/kiter https://preesm.github.io https://www.researchgate.net/publication/220714226_DIF_An_Interchange_Format_for_Dataflow-Based_Design_Tools

FPGAs are reconfigurable chips and offer promise of very high performance, low powered targets for accelerated computation. They have potential in many domains including High Performance Computing, Cloud Computing, embedded processing and autonomous robotics. FPGAs are usually programmed at very low levels with hardware description languages, and sometimes at the higher level C language. High level parallel array processing languages like APL, Accelerate and Chapel abstract above hardware, usually targeting multicore CPUs and GPUs. This project will involve writing an FPGA backend for the Accelerate DSL, an embedded language in Haskell, Backend options are OpenCL or C++, from which High Level Synthesis tools will generate FPGA hardware designs. This is a compiler research project that will establish how to produce high performance (outperforming parallel CPUs and GPUs) and efficient hardware from very high level array processing codes.

Neural networks have until recent times predominately been trained and executed on GPUs in data centres. The recent trend is to push trained neural networks to Edge Computing devices, such as smart phones, autonomous vehicles and smart cameras. One hardware architecture in this space are FPGAs, which are programmable hardware chips that can be deployed with a sensor for low powered operation, reaching extremely high throughput. This makes FPGAs ideally suited for data driven AI problems that involves high volumes of input data and where a high throughput of inferences are required. One downside of FPGAs and other Edge Computing AI accelerators, is that they are limited in how much memory they have to store trained neural network parameters. The solution is the compress neural networks, e.g. by quantising the precision of their weights. Doing so has an inevitable effect on inference accuracy, but this is a surprisingly small amount. Another, more serious, effect of quantisation is the loss of robustness a neural network might have against adversarial attack. Currently, quantisation algorithms focus on the trade off between accuracy and memory requirements. This project will instead design a new quantisation algorithm, one that guided by formal verification approaches such that reducing precision of neural network parameters does not affect the robustness of the overall network to adversarial attack. This will be done in the context of the open source Brevitas component in the FINN compiler framework developed by Xilinx Research. This project can be done in close collaboration with Xilinx Research if the student wishes.

Haskell is an almost unique language, in the sense that it has lazy-by-default evaluation semantics and it is a pure language (no side effects). Laziness poses challenges for reasoning about memory performance and memory access behaviours. Existing profiling tools for Haskell do not measure the latency of memory access, or the contention on the memory bus for parallel Haskell programs. This project will investigate how to use low-level tooling to evaluate the cost of Haskell's properties of (1) laziness and (2) immutability (purity), when it comes to memory access costs. E.g. how long to CPU cores need to stall waiting for code and data from memory, and how much contention is there on the serial memory bus when running parallel Haskell programs on up to 64 CPU cores. This project will involve lifting very low level profiling information into the context of Haskell user code.

A huge effort has been put into optimizing LM pretraining at massive scales in the last several years. While growing parameter counts often get the most attention, datasets have also grown by orders of magnitude. For example, Chinchilla sees 1.4 trillion words during training---well over 10000 words for every one word a 13-year-old child has heard in their entire life. The goal of this shared task is to incentivize researchers with an interest in pretraining or cognitive modelling to focus their efforts on optimizing pretraining given data limitations inspired by human development. Additionally, we hope to democratize research on pretraining—which is typically thought to be practical only for large industry groups—by drawing attention to open problems that can be addressed on a university budget.

Current Deep Learning models of language processing assume to have access to a tokenizer, a tool used to divide the input text into a sequence of tokens that can be more easily processed by Machine Learning algorithms. A tokenizer is built utilising a textual corpus from which it derives the most frequent tokens used in the language. However, these representations have several short-comings: 1) they are specific for each language; 2) they are sensitive to noise (e.g., spelling mistakes); and 3) they are hand-crafted because they do not represent language input in a multimodal way using either the visual or auditory input streams, just like humans do. To overcome these bottlenecks, this project will explore "textless" NLP models that use visual and audio signals to derive latent conceptual representations.

Investigate resources that can be used to create large language models that can understand, and manipulate different forms of charts in an interactive way.

Current large language models learn from static dataset made of text, images or videos. However, a learning agent should be able to learn from the interaction with the world and with other agents. In this project, we will create a simulated environment based on Unity to facilitate learning objects and tasks in a multimodal way.

The student will investigate recent advances in Vision+Language models and apply them to the challenging domain of medical imaging. The student will work with the supervisor to identify a domain of interest and scope it for the purpose of the master project.

Current large language models like ChatGPT and Bard have remarkable abilities to generate very fluent natural language and they have achieved impressive performance on several benchmarks. However, for many relevant tasks in the real world, we have to make sure that these models can also interact with external sources (e.g., Wikipedia or search engines) as well as other external tools such as calculators, databases and so on. In this project, we will explore the field of large language models that can use external tools to achieve very specific goals and tasks.

In this project, we will explore efficient deep learning architectures for training artificial agents that can learn to execute actions in the environment. For instance, we will investigate whether it's possible to train models that can learn to play ATARI games.

This project explores the application of Large Language Models (LLMs) to develop a recommendation system for scientific articles. Traditional recommendation systems often struggle to fully grasp the nuances of scientific literature. LLMs, with their powerful language processing abilities, hold promise for creating a more sophisticated system.

π-base is an extensive database of topological spaces and theorems. It is of use to mathematicians looking to find: 1. examples of topological spaces satisfying certain properties, 2. theorems that can help them deduce other properties of their spaces, and 3. counter-examples to conjectures. Currently it lists theorems such as "if your space has property A then it has property B", "if your space has property ¬C & D then it has property B", etc. It would be nice to add new functionality to this website so that a user can list a property they want to prove and it can give them a tree of all the sequences of theorems they may need in order to prove it. This would be a useful project for someone interested in typescript, web programming, and someone wanting to contribute to an open source project.

The different Large Language Models (LLM) have different strengths. This project does not aim to build LLM models but to utilise existing LLM API services for the purposes of grading short English essays. It is predominantly a software development project for an application that can accept single or multiple essay submissions and grade them. There should be a backend connector to APIs and the intent is also to evaluate which LLM API would be most suited for automated essay scoring (AES). This should be evaluated based on human-computer agreement on the scoring.

The recommendation domain is open to discussion, it can be for a single domain or a multi-domain (meals, sports, drinks, movies). The current default recommendation using LLMs such as ChatGPT is generic and does not take into account of the user's location, the user's preference, past events (need to store), or popularity of the recommendation. This project is a software development project, with historical logs, and prompt engineering to effectively query a Large Language Model API to provide recommendation. The project should also have a measure of effectiveness or impact to the users.

To be updated.

Event-B is a modelling language that can be used to specify mathematical models of transitional systems. Spiking neural P systems are the result of introducing the idea of neurons into membrane computing. The main goal of this project is to give a methodology to obtain the Event-B model of a SN P systems, to apply it on some examples and to verify the properties of the model using Pro-B, a model checker integrated into a platform called Rodin.

Event-B is a mathematical modelling language that can be used to model various transitional systems. The aim of the project is to develop a methodology for constructing Event-B models of non-deterministic algorithm, to apply it on several case studies and to investigate these by using the model checked ProB.

TBU

RPA bots could be implemented in areas as diverse as finance, compliance, legal, customer service, operations, and IT (student’s choice). Students can choose to implement attended automation, i.e., software robots that can work alongside humans to share the workload in real-time. In case of unattended robots, they should be scheduled to handle long processes or automations without the need of human interaction. Prove the usability of RPA in several use-cases (https://docs.uipath.com/robot/docs/attended-vs-unattended).

A comparative study of Process Mining and RPA, highlight the benefits of putting them together, as well as the key differences between these two. Provide an overview of the context and end-to-end viewpoint to enhance processes and ensure the successful delivery of automation-driven outcomes. Research how process mining helps identify the most suitable processes for RPA The project should contain some use cases.

Highlight the benefits of using Automation (RPA) combined with ML models. The research should involve some use cases. Explain Intelligent Process Automation.

Highlight the benefits of using Process Mining combined with ML models. The research should involve some use cases.

TBC

Classification and segmentation of UXO using hand-crafted features and CNN using miami dataset

Computer Vision

Computer Vision

Computer Vision

Computer Vision

Computer Vision

Healthcare analysis

Computer Vision

Designing a flood prediction system using machine learning approach

Research and develop a hybrid authentication approach for security of eCommerce application.

Service Oriented Architecture for Smart homes

Using Drones technology and computer vision for dust detection and cleaning of solar panels.

Developing a Q & A system on Biomedical data using Large Language Model (LLM). An existing pre-trained model can used and fine tunned on new data.

Amyotrophic lateral sclerosis (ALS) is a rapidly debilitating neurodegenerative disease that affects motor neurons. Patients develop progressive muscle weakness, leading to death due to respiratory failure, which typically occurs after 3–5 years of symptom onset. ALS affects 1.75 – 3 out of 100,000 individuals per year. The existence of protein aggregates (TDP-43) in affected motor neurons is still a poorly understood hallmark. This project aims to increase the understanding of these structures by using a real clinical Immunohistochemistry dataset collected by the University of Edinburgh and applying different machine learning techniques to extend the understanding of the TDP-43 aggregates at an individual level. This project aims at characterising in more detail how distinct species of aggregates and their distribution are presented in different cells and different patients.

Parkinson’s Disease (PD) is a neurodegenerative disease of high incidence in the ageing population. This project aims at the application of deep learning technologies to a clinical dataset that contains information on patients with prodromal or early-stage PD. By analysing and processing digitalised movement data captured by three standard clinical assessments, the classifier will be expected to characterise bradykinesia, a slowing of movement, which is the fundamental motor feature of PD. The complex nature of bradykinesia makes it difficult to reliably identify it, particularly at the early stages of the disease (Ahlrichs and Lawo, 2013). The types of clinical assessments used in this study are the following: * Finger tapping * Hand pronation-supination * Hand opening-closing * Hand movements measured by accelerometers

In the context of machine learning, when the amount of labelled data is limited, like in most of the cases in the medical field, data augmentation is a critical pre-processing step for training Deep Neural Networks. This enhances the invariance and provides robustness. Amyotrophic lateral sclerosis (ALS) is a rapidly debilitating neurodegenerative disease that affects motor neurons. Patients develop progressive muscle weakness, leading to death due to respiratory failure, which typically occurs after 3–5 years of symptom onset. ALS affects 1.75 – 3 out of 100,000 individuals per year. A real clinical Immunohistochemistry dataset was collected by the University of Edinburgh, visualising protein aggregates (TDP-43) in affected motor neurons. Due to the length of the dataset and the characteristics of deep learning, the final accuracy increases significantly with the application of augmentation techniques. When dealing with images, the process of augmentation can involve the use of simple transformations of the existing images to create new ones. I am interested in testing the applicability of Generative Adversarial Models as a suitable augmentation technique for this dataset and assessing how much a final Convolutional Neural Network can benefit from this technique in comparison to the application of more simple approaches.

Traditional methods of diagnosing ear diseases often involve manual interpretation of clinical symptoms, which can lead to subjective results and delays in accurate treatment. This project seeks to develop a robust and accurate diagnostic tool that can analyse a range of ear-related symptoms to identify and classify various ear diseases. By leveraging a medical image dataset, the project intends to train advanced machine learning models to recognise patterns indicative of different ear conditions, including otitis media, otitis externa......The success of this project has the potential to improve patient outcomes, reduce misdiagnoses, and provide a reliable and accessible tool for healthcare professionals, ultimately advancing the field of ear disease diagnosis and treatment. This project is in collaboration with Dr Fernando Auat (ISSS/EPS)

Objective: The objective of this project is to analyse and predict financial market volatility using machine learning algorithms and quantitative modelling techniques. The research will focus on developing models to forecast volatility in different financial instruments. Potential milestones for the project: ============================== Introduction: * Overview of financial markets and the importance of volatility prediction. * Literature review of existing volatility forecasting models. Data Collection and Preprocessing: * Gathering historical market data for various financial instruments. * Preprocessing the data for analysis, handling outliers and missing values. Quantitative Modelling for Volatility: * Implementing stochastic calculus and partial differential equations for volatility modelling. * Utilising Monte Carlo simulations for pricing and risk management. Machine Learning Techniques for Volatility Prediction: * Applying time series forecasting algorithms for volatility prediction. * Implementing and fine-tuning quantitative models and machine learning algorithms. * Evaluating and comparing the performance of different ML models. Risk Management and Portfolio Optimisation: * Developing Value at Risk (VaR) models and stress testing for risk management. * Optimal portfolio allocation based on volatility forecasts.

Assessing the symptoms of Parkinson’s Disease (PD) and their changes under medication effect is essential to design effective symptomatic treatments and putative disease-modifying agents. Real-world monitoring of gait reflects ecologically valid motor fluctuations over minutes and days. However, this has not yet been implemented to predict and assess symptomatic treatments in PD. Thus, this project globally aims to develop objective, cost-effective, valid and novel methods for real-world gait assessment in PD with a single wearable sensor. Particularly, it focuses on predicting and assessing the effect of anti-parkinsonian medication (dose, frequency and time from intake) on gait patterns. The methodological novelty resides in the calculation of gait characteristics (spatiotemporal, signal-processing-based, based on stochastic analyses, etc.) with a data-driven approach. This project will be carried out in collaboration with Oregon Health & Sciences University (OHSU), USA, and will be primarily supervised by Dr. Encarna Micó Amigo and Dr. Marta Vallejo.

Description: Develop an application that visualises health data from wearables (to be decided), such as heart rate and blood pressure, in real-time through Microsoft Hololens 2. This system could help users keep track of their health status and make informed decisions or be used for carers to monitor home patients (elderly or other frailty groups). This project will also be supported by Dr Alistair McConnell (alistair.mconnell@hw.ac.uk).

In this project, we will assess the ability of classification models to create an intelligent agent for video-game playing by learning from expert data. The idea consists of first capturing a sample of play sessions from expert players to create a training data set. Next, we will apply different Machine Learning models and a Symbolic Classification model to create an intelligent agent that mimics the actions of the expert player and evaluate the extrapolation abilities for later stages. We will also evaluate different approaches that help to improve the extrapolation abilities of the model and assess the performance of the agent by how far they can play the game. Additionally, we will debug the symbolic models to understand the agent behaviour and improve their performance.

In the context of assistive technologies for the elderly or people with disabilities, intelligent environments have been designed to empower this public with more autonomy in daily activities. To this aim, sensors and actuators embedded in the environment or in social robots might be orchestrated to produce helpful behaviours. In any case, deploying this type of technology requires that the system identifies the state of the environment and the users. This understanding can be achieved through activity recognition methods, many of which are presented in the literature with good results in several applications. However, these methods usually require data from several users to be concentrated in a centralised computational base to train machine learning models. This requirement, especially considering modalities such as videos or audio, raises ethical and legal concerns regarding data privacy. In this work, we propose to train the models locally for each participant using a Federated Learning approach to induce models based on public datasets such as the HWU-USP dataset. This approach preserves privacy because it does not require that the data is transferred out of the user’s environment, only partially trained models. Metrics such as time elapsed and accuracy will be evaluated.

This project is part of a wider project and aims to contribute to the development and understanding of a Neurorobotics model of Parkinson’s Disease (PD), the Neuro4PD project (http://www.macs.hw.ac.uk/neuro4pd/). You will work with a neurorobotics model of PD currently being developed by our team with the goal of further understanding its computational properties. In particular, your work will investigate the computational capabilities of the BG-T-C loop in generating diverse control signals that can be exploited in robotics tasks. Then, you will compare neural computations in the BG-T-C loop with and without a robotic body. Overall, your work will be a further step in understanding the neural mechanisms underlying PD.

This project is part of a wider project and aims to contribute to the development and understanding of a Neurorobotics model of Parkinson’s Disease (PD), the Neuro4PD project (http://www.macs.hw.ac.uk/neuro4pd/). In this project, you will work with a neurorobotics model currently being developed by our team with the goal of further understanding how complex motor control can be accomplished from realistic computational neural models embedded in simulated and real robots engaged in challenging tasks. In particular, you will explore current neuroscience findings with the goal of translating core neural mechanisms to practical robotic controllers. Overall, your work may also lead to novel AI architectures for embedded systems.

Deep convoloutional networks have been widely deployed in modern cyber-physical systems performing different visual classification tasks. As the fog and edge devices have different computing capacity and perform different subtasks, models trained for one device may not be deployable on another. Knowledge distillation technique can effectively compress well trained convolutional neural networks into light-weight models suitable to different devices. However, due to privacy issue and transmission cost, manually annotated data for training the deep learning models are usually gradually collected and archived in different sites. Simply training a model on powerful cloud servers and compressing them for particular edge devices failed to use the distributed data stored at different sites. This offline training approach is also inefficient to deal with new data collected from the edge devices. To overcome these obstacles, in this project, a heterogeneous brain storming (HBS) method is implemented and developed for object recognition tasks in real-world Internet of Things (IoT) scenarios. This method enables flexible bidirectional federated learning of heterogeneous models trained on distributed datasets with a new “brain storming” mechanism and optimizable temperature parameters.

As a fundamental problem in chemistry, Retrosynthesis is the process of decomposing a target molecule into readily available starting materials. It aims at designing reaction pathways and intermediates for a target compound. The goal of artificial intelligence (AI)-aided retrosynthesis is to automate this process by learning from the previous chemical reactions to make new predictions. Although several models have demonstrated their potentials for automated retrosynthesis, there is still a significant need to further enhance the prediction accuracy to a more practical level. This project aims to review, implement and review existing retrosynthesis methods and their potential applications.

SARS-CoV-2 pandemic has more than 1.6 million deaths worldwide by the end of 2020 and has overwhelmed health care resources in most countries. Medical imaging, especially chest CT and X-ray techniques have played critical roles in the diagnosis and treatment planning of COVID-19. In the past two years, a large number of deep learning methods have been proposed to: 1. assist the analysis and post-processing of chest imaging data; 2. predict the possible clinical outcomes and development of disease; 3. predict the spreading speed and pandemic status in human society; 4. etc.. This project will develop deep learning methods that can directly benefit the efficiency and accuracy of clinical analysis for COVID-19 using the available public challenge dataset (the STOIC2021 competition: https://stoic2021.grand-challenge.org/stoic2021/). Then focus on the analysis and assessment of explainability of currently mainstream models (ResNet variations: ConvNeXt, Transformer, gMLP, GNN, etc.) Purposes and milestones: Specifically, this project will develop DL models for to predict: 1. Predict COVID19 positivity. 2. Predict occurance of severe COVID-19 cases, defined as intubation or death within one month from the acquisition of the CT scan (metric: AUC). Milestones of this project: 1. A simple ConvNeXt model applied to STOIC2021 data and produce result (successfully submit to the competition) 2. review, collect, implement and compare the SOTA deep learning models on STOIC2021 models, you may use some extra data 3. review and implement different ways to assess the explainability of different models 4. Assess the explainability for different models

Skalpel helps explain type errors in computer programs. The project would build an additional front-end (user interface) for Skalpel by making it usable from within Eclipse. Because support for SML in Eclipse is probably not the greatest, this project could reasonably include general work improving this support.

Isabelle/Isar is a widely used proof assistant and proving environment for formal verification. There is no single place where a complete and up-to-date definition of the Isabelle/Isar input language can be found. Some of the pieces are in research publications, some pieces are in PhD dissertations, some pieces are in software documentation, and some pieces are in the Isabelle/Isar source code. And only the source code is certain to be up-to-date. This project is about gathering the pieces, assembling them, and writing some tests to confirm that the definition that the project synthesizes is correct.

The supervisor of this project is trying to develop general theories of mathematical texts. As part of this, it is necessary to see what computer scientists, logician, mathematicians, etc., actually write. Search engines are great for finding documents by the words or phrases they use. However, they are not much use for searching for instances of BNF-like notation (M, N ::= x | lam x. M | M N), or set comprehensions ({ x | exists y. (x,y) in S }), or ellipses (x = (y1, ..., yn)), or other mathematical notations. This project is about developing programs to process documents to gather samples of the various forms of these and similar notations.

Skalpel helps explain type errors in computer programs. Although there are a number of specific projects listed for Skalpel, there are lots and lots of other possible projects, far too many to write a project proposal for each one. Just ask.

System F is a type system that is embedded as part of the essential core in type systems used by many programming language and proof systems. The key idea of System F is the forall-quantified type, e.g., the type (forall x. x to x) stands for the collection of all types of the shape (Z to Z) for any Z. System Fs extends System F with _expansion variables_ to enable a particular way of using constraint solving for finding types for programs and proof skeletons with incomplete type information. This project is about implementing the key features of System Fs and exploring possible constraint solving algorithms.

The lambda-calculus is the standard theory for reasoning about computer programs. Machine language is what available CPUs actually run. This project involves investigating a machine-language-like formalism with the equational reasoning power of the lambda calculus. Useful tasks that might be part of the project include implementing the language and testing or verifying its properties.

Skalpel helps explain type errors in computer programs. The project would improve testing, find bugs, and improve robustness. Much earlier work has been on theoretical challenges, with less time spent on niceties like, for example, good error messages and test coverage. The project might also finish moving the web site to GitHub.

Parse and/or give formal semantics to mathematical uses of English combined with symbolic formulas. The starting point is to read the Language of Mathematics by Mohan Ganesalingam and then scan the research in the decade since this book was published. Then some part of the problem must be determined as the goal. Then implement and test and evaluate.

Skalpel helps explain type errors in computer programs. Programmers of the front-end (user interface) have included me, 2 PhD students, and 5 project students, with the result being code that is fragile and hard to modify. A good project would be to rewrite it with proper care for data structure sanity, error checking, error messages, testing, etc.

Hume (http://hume-lang.org/) is a language using ideas from both functional programming and finite automata together with strong types to obtain guarantees on time and space usage for safety-critical systems. The project would begin the process of extending the type error explainer Skalpel so it can find the portion of a Hume program responsible for a type error. Most likely only part of Hume will be handled. This would also begin the process of extending Skalpel to analyze multiple languages.

Skalpel helps explain type errors in computer programs. The project would extend Skalpel's back-end to generate graphical type/data-flow diagrams that will show how the program parts causing a type error are connected. Tom Methven (RA for Mike Chantler) can help a bit. Tom and Mike recommend the D3JS library (http://d3js.org/).

PDF is now much more than a system for arranging ink marks on paper. PDF now includes many new features from 3D visualizations that can be manipulated to dynamic adaptation to changes in media size and shape. One particularly important feature is fancy form filling with programmable checking of entered data. It is particularly important for there to be an open source implementation of these features, because they are often used for mandatory government reporting and it is not good for this kind of functionality to be controlled by a private company. This project aims to assess which parts of the standards in this area that Adobe has put forward are most important to implement as open source, and then to carry out and test and deliver some specific improvements to some specific pieces of open source software.

Distributed ledger promotes decentralisation and immutability of stored data. Taking this further, the ledger can also be used to empower individuals to have control over their identities and provide credentials in a minimised trust environment. This project requires a distributed ledger or blockchain-based identity management system to be set up, and its capability to manage and provision of credentials to be demonstrated.

Working with the relevant persons at HW facilities management, create a possibly real-time application of lift usage.

This is a software engineering project where requirements need to be collected from both staff and students. It may be split into two separate projects. From the student perspective, it should help student meet the submission deadline. From the staff perspective, it should visualise the impact of the change in one deadline. Usability is also important.

KHDA has open data with details of schools in Dubai.This project can help parents decide which school to send their children too. The deliverable is a 'website' that parents can use. Computer systems students can focus of the development aspect of such a project, Computer Science student can include the topic of visualisation. Both cohorts can explore the inclusion of analytics.

This is a project for building a website or an app with functionality to be determined based on the context.

There is a wide offering of social media. This project will investigate the strength and weaknesses of each platform and look into which features are best suited to overcome isolation, then develop an app that incorporates the important features. A colleague from psychology can be consulted.

The Library if full of valuable references which can help in the various courses. Starting with the course descriptor of a course, identify available reference, and whenever such a reference is consulted, it gets rated. Think: "Tripadvisor for books".

In this project you will at random replace very short words such as in, the, of, at... with a number of blanks equivalent to number of letters in the word. As the user enters these correctly, proving that the user is reading the text, the number of blanked words can reduce. The text could be the honours project student handbook. There is scope to add additional features such as gamification or visualisation.

Student-proposed project

A range of applications such as - leveraging the availability of devices such as smart meters to reduce consumption of electricity in the home -leveraging the availability of open data to create smart communities and many more.

This project can look into analysing health-related data. For visualisation it could include the development of an animation to track the progress of e.g. Covid in one country, or it could visualise a region and map one country within that region, or compare countries with similar size populations or similar climates or geographic locations.

Research what keeps an audience captivated and feed back to a public speaker via an app.

Here are two links to explore and https://journals.ub.uni-heidelberg.de/index.php/dah/article/view/21631 or perhaps https://towardsdatascience.com/tagged/digital-art The Psychology department have recently acquired a mobile eye tracker with a capability to be incorporated with a VR headset. They are looking to using it for some eye movement research related to digital/ immersive art (Dr. Pik Ki Ho https://www.hw.ac.uk/dubai/profiles/teaching/dr-pik-ki-ho.htm will be co-supervisor)

We will use the OpenAi gym as platform for training and evaluation

Exploratory Data Analysis on published datasets containing gene expressions for blood tumor patients. Development of ML models to identify possible biomarkers for earlier detection of the disease.