3DT and Friends Event 2016

This one-day event showcases the research of postgraduate students from across the Centres for Doctoral Training, the School of Informatics, and related areas in the School of Mathematics.

The event is jointly organised by the:

• EPSRC CDT in Pervasive Parallelism
• EPSRC CDT in Data Science
• EPSRC CDT in Robotics & Autonomous Systems

The day will present a snapshot of the wide-ranging research from across the School of Informatics, and will facilitate networking and collaboration across CDTs, companies and research areas.

Agenda

Presentation Titles and Abstracts

• Presentation Session 1

Panos Stratis, Laboratory for Foundations of Computer Science

Test Case Permutation to Improve Energy Consumption

Executing large test suites is expensive, both in terms of time and energy with cache misses being one of the main factors contributing to execution time and energy consumption of software. Cache misses are reduced by increasing the locality of memory references. In the present work we explore cache locality optimizations across several program runs, which is the case when we run several test cases.

Rafael Karampatsis, CDT in Data Science

A comparison of different large scale language models for source code

In this talk we demonstrate a comparison between state of the art statistical language modelling techniques applied on big source code corpora of different programming languages. Research into building language models of programming languages is important because this can enable further research into applications such as code completion and suggestion tools, bug fixing, and automatic code translation, amongst others.

Caoimhín Laoide-Kemp

Streaming Communication Patterns for Domain Decomposition Methods

One of the most significant challenges faced by parallel computing is that of efficient communication between processors. This is becoming more and more important as the industry advances towards exascale computing, as many current algorithms will not scale to the required numbers of processors.

One such algorithm is halo exchange – a standard communication pattern for problems that are decomposed by domain. This talk will discuss some of the problems with using halo exchange on exascale machines, and also explore the advantages of a stream-based alternative.

Victor Dumitrescu, CDT in Pervasive Parallelism

Formally verifying large software systems

Formal methods can give the strongest guarantees about the correct behaviour of software, but formally specifying and proving the correctness of real-world systems is notoriously difficult and expensive. As more and more ambitious verification projects are being completed, such as the CompCert C compiler and the seL4 microkernel, the challenges they faced reveal how interactive theorem provers can be improved to better support these large, collaborative efforts.

• Presentation Session 2

Charlie Nash, CDT in Data Science

Modelling 3D Object Classes with Parts

A model of the geometric and semantic relationships present among object classes can be a considerable aid in computer vision applications. Additionally, content creation is a central task in computer graphics, and a shape model can be used to synthesize realistic objects that can be placed within a scene. We present a system that can learn to generate novel instances of an object class using a collection of examples from that object class as training data.

Arpit Joshi, Institute for Computing Systems Architecture

Non-volatile Memory: Optimizing for Performance

The emerging non-volatile memory (NVM) technologies (like 3D XPoint) provide the opportunity for tremendous improvement in performance of applications that require access to persistent data. However, this opportunity comes with the challenges of ensuring consistency of data in the presence of failures. In this talk we will discuss some techniques on how to improve performance in systems with NVM while ensuring consistency of data in the presence of failures.

Simon Fowler, CDT in Pervasive Parallelism

Relating Channel- and Actor-based Models of Concurrent Programming

Akka, Elixir, Erlang, Go: these are a few of the languages and frameworks which take concurrency and communication to be a focal point in language design. Actor-based languages such as Erlang have found much use in implementing scalable and fault-tolerant distributed systems, and channel-based languages such as Go have found much use in systems programming. But how do they relate to each other, and what can we learn from this?

In this short talk, I’ll give a high-level overview of my work in relating these two models of communication-centric programming, both in the case where channels and actors can send and receive values of a single type, and where channels and actors can send and receive values in a sequence corresponding to a communication protocol.

Ross McKenzie, CDT in Robotics & Autonomous Systems

Soft Robotics Grippers

Soft Robotics is the study of the use of flexible and extensible materials in robots. Soft robotic grippers can deform to mimic the shape of an object automatically, allowing for robust gripping of unknown and delicate objects. This gripping can also be achieved with less complex control than standard grippers.  This presentation provides a brief introduction to the field of soft robotics and showcases its use in grippers.

Bobby Ikonomov, CDT in Data Science

The application of Quantum Computing to Machine Learning

Quantum computing is becoming an increasingly popular topic as of late, with progress being made both in theoretical and experimental fronts. Not surprisingly, researches have recently started to explore the possible application of quantum computing to another prominent field – machine learning. This talk will give a brief summary on the very new field of Quantum Machine Learning and attempt to answer several important questions, such as: How can quantum computing potentially be used to improve machine learning? What relevant algorithms have been already proposed? What are the challenges in implementing these algorithms? When can we expect quantum computers to become practical for machine learning?

• Presentation Session 3

Vanya Yaneva, CDT in Pervasive Parallelism 

Accelerating Software Testing using GPUs

In software engineering, careful validation of the developed system is a crucial task, which involves the generation and execution of a large number of test cases. Thus, rigorous testing of any non-trivial system could be extremely time consuming, putting an enormous strain on software development cycle. One way to accelerate software testing is to execute test cases in parallel on the GPU threads. In the talk, I am going to present this idea, the challenges of implementing it and how I am addressing them.

James Owers, CDT in Data Science

Deep Music

Deep learning has had its greatest successes in the domain of images. Can we apply similar techniques to the domain of music? What can we do with deep representations of music? How hard would it be to make a generative model?

Philip Ginsbach, CDT in Pervasive Parallelism

Enabling Compilers to Exploit Heterogeneous Computing

Heterogeneous computing is becoming increasingly important for exhausting the potential of current hardware platforms, but established programming models using OpenCL and CUDA require much technical expertise. Specialized libraries such as cuBLAS or cuFFT expose more concrete functionality and are well optimised by expert programmers but are each limited in scope. We present an approach that will enable compilers to automatically spot functionality that suits particular interfaces and then substitute it with library calls.

Andy Brock, CDT in Robotics & Autonomous Systems

Introspection: A Walk in Latent Space of Variational Autoencoders

A brief discussion on the relationship between generative and discriminative modeling, and a real-time visualization demonstration.

• Presentation Session 4

Justs Zariņš, CDT in Pervasive Parallelism 

Runtime management for asynchronous algorithms

I will talk about iterative asynchronous algorithms – in essence trading correctness for performance. Specifically I will share my findings on trying to manage at runtime an asynchronous algorithm running on a shared memory node. The goal of the management is to limit work progress imbalances without sacrificing convergence speed and tolerance to noise.

Matt Graham, Institute for Adaptive & Neural Computation

Sampling under constraints in deep density models

There have been several models proposed for learning probability densities across high-dimensional continuous data by optimising the parameters of an invertible map which transforms the data to a new space where it is (approximately) distributed with some simple density e.g. Gaussian. To independently sample from the learnt joint distribution we can then draw independent samples from the simple density and transform these through the inverse of the learned map. I will present my work on a MCMC method for sampling in such models under constraints in the original data space e.g. due to conditioning on a subset of dimensions having known values.

Valentin Radu, Institute for Computing Systems Architecture

Deep sensing with wearable devices

The large volume and rich data that can be collected with our pervasive mobile devices gives rise to a new perspective of interacting with our environment. In this talk I’m going to present my work concerned with the first step of this process, detecting user context from sensor data, the challenges involved in squeezing deep learning onto limited resource devices and the vision of how these can lead to more natural human computer interactions.

Adam Harries, CDT in Pervasive Parallelism

Sparse and irregular parallel processing on GPUs using functional languages

Many real world datasets, and the parallel algorithms acting on them involve high levels of workload irregularity. This poses a challenge for GPU parallelisation, as GPU architectures tend to favour highly regular, data parallel computations. In this talk, I will present our work in expressing irregular computations in a regular pattern-based functional language, and generating efficient OpenCL code from the resulting expression.