Previous Undergrad Research Awards

Previous Projects

Summer 2023

Dongwook Yoon

Meta-humanoid: Evaluating the Effects of Realistic AR Avatar in Social Interaction with Humanoid Robot

Meta-humanoid is a novel telepresence application that synthesizes a suite of cutting-edge technologies, including humanoid robots, life-like avatars, and augmented reality to reduce the user's perceptual discordance between the robot's body and the human teleoperator's identity.  In meta-humanoid, the user wears an AR HMD that overlays the teleoperator’s lifelike avatar on a humanoid robot. The lifelike avatar moves and animates according to the humanoid’s motion. This can reduce the user’s perceptual discordance.

In canonical robot-mediated telepresence applications, a teleoperator controls a robot to offer physical services to a user. However, the machine-like appearance of the robot is a critical barrier for the user to perceive the robot as the embodied self of the teleoperator. The user’s perceptual discordance between the actor’s embodiment (i.e., the robot’s body) and its identity (i.e., the human teleoperator) leads to diminished quality of emotional and cognitive experiences, such as trust, likeability, and presence. This gap hampers the potential of telepresence robots in domains like telemedicine and tele-training where emotional and perceptual quality is critical.

In this research, we aim to evaluate the impact of the lifelike avatar overlay on the perceptual quality of social interaction in meta-humanoid applications. We leverage a Wizard of Oz approach, where the user is immersed in a fully VR environment in which a confederate researcher plays the role of the humanoid robot controlled by the teleoperator.

Keywords: Augmented Reality, Tele-presence Robot, Social Interaction, Usability Evaluation

Qualifications:

  • (optional) HCI evaluation skills or successful completion of the introductory HCI courses (e.g., CPSC 344)
  • (optional) Experience or strong interest in UX evaluation methods (e.g., user study, survey, interview)

(optional) Successful completion of the Computer Graphics course (e.g., CPSC 314)

 

Dongwook Yoon

Augmenting Zoom Meeting Experiences with an AI Moderator

Zoom meetings have become a widespread form of communication, but the video conferencing system itself offers little more than the transmission of pixels. The aim of this project is to create an "AI moderator" agent that aids meeting participants in browsing, comprehending, and annotating video content from Zoom meetings. The intern will work on constructing the system by utilizing a combination of AI techniques such as computer vision, speech recognition, and natural language processing.

Qualifications:

  • Strong technical skills including OOP, data structures, and algorithms
  • Experience in building computer vision, speech processing, and/or natural language processing applications

(optional) Experience in web front-end development

 

Kevin Leyton-Brown

Automatically synthesizing efficient algorithms for solving SAT

Please contact Chris Cameron at cchris13@cs.ubc.ca if interested and to set up a time to talk.

Designing efficient algorithms for solving the Boolean satisfiability (SAT) problem is crucial for practical applications such as scheduling, planning, and software testing. Machine learning is an important tool in algorithm design for SAT, however SAT practitioners have yet to exploit the representational power of deep learning. We are working on training neural networks to learn to make variable ordering decisions for the widely used DPLL-style SAT solvers. DPLL SAT solvers search for a solution in a tree-like fashion, where a "branching policy" dictates how to iteratively partition the search space. Existing heuristics for deciding how to partition the search space don't use machine learning to leverage the structure of the internal solver state. Inspired by AlphaGo, we developed Monte Carlo Forest Search, a reinforcement learning approach for learning branching policies that lead to small proof trees of unsatisfiability.

To date, we have achieved a working implementation with performance gains on small-size SAT distributions. The student will join in to help us scale up our method to work on much larger and more difficult SAT distributions that are more typical in industrial applications.  We see two main bottlenecks to achieving this. The first is memory requirements for model training. A few ideas we would like to explore with the student are parallelizing across GPUs, memory-efficient gradient approximations, and smaller state representations. The second challenge is exploring an action space that is many orders of magnitude larger. We think a promising direction is to learn an action representation and reduce the action space by collapsing similar actions together. To manage the challenge of jumping from a few hundred variables to a few million, we plan to build a curriculum-learning
pipeline to gradually increase problem size and iteratively leverage policies from smaller problems.

The student will work closely with Leyton-Brown's graduate students. They have primary responsibility for well defined tasks (usually implementing aspects of a system, running computational experiments, and analyzing the results) but also often get involved in problem (re)formulation and generating new research ideas.

Qualifications:

The student should have a basic understanding of machine learning concepts and should be competent in C++ (for SAT solver) and Python (for ML). Knowledge of deep learning (pytorch), cluster computing, statistics, and CDCL SAT solvers will be an asset.

Student responsibilities:

The student will learn how to (1) design large computational experiments (2) leverage neural networks (specifically graph neural nets) and (3) modify and implement monte-carlo tree search. Neural nets are ubiquitous in industry and Monte Carlo Tree Search is becoming a major method with many potential applications in the coming decade. The student will also get exposure to the research process which will be beneficial for any future graduate program they might attend. The student will have close interaction with Leyton-Brown and his graduate students and learn research methodology, including how to come up with research questions, design experiments to test hypotheses, and effectively communicate research arguments.

Work Setting: Mostly on campus with some online.

 

Thomas Pasquier

Understanding the performance of graph-based anomaly detection

The history of a system execution can be represented as a directed graph. Nodes in the graph represent states of system objects (e.g., processes, files, sockets, etc.) and edges represent interactions between those objects (e.g., read, write, fork, etc.). This graph can be analyzed to understand how the states of two objects relate. In practice, each implementation of this concept represents system execution history differently, leading to graphs with very different properties.

Over the last ten years, many papers have looked at machine learning techniques to analyze those graphs and automatically identify anomalous patterns. More attention should be paid to the underlying graph semantics and how it affects detection performance.

In this project, you will systematically study the interplay of the graph representation semantics and the detection performance. The ideal student will be comfortable with applied machine learning techniques, and systems development and management. Time permitting you will leverage this knowledge to design a better anomaly detection system.

 

Alexander Summers

Proof Construction from Rust Compiler Analyses

The Rust programming language incorporates a unique type system for governing, in a fine-grained way, the management of aliases, mutation and allocations, forcing programmers to provide much richer information about their intentions than in other mainstream languages. This type system is supported by a number of complex compiler analyses: a combination of classical program analyses such as liveness information with Rust-specific analyses such as borrow and reference lifetime tracking. The Prusti project (along with many other subsequent works) observed that this information could be leveraged to simplify formal reasoning about what Rust programs actually do, and in particular to query the compiler for information that helps to construct a mathematically-precise modelling of a Rust program into another language (Viper) and toolset suitable for program verification.

While this research direction has been successful, Prusti’s current approach intertwines the modelling of Rust into Viper with the information we need to extract from the Rust compiler. This makes the code difficult to develop, and means that the current techniques cannot be easily used to experiment with other back-end encodings and verification techniques. In recent work, we have been exploring the possibility of defining a fully-elaborated form of a Rust program enriched with information from compiler analyses, explaining its interactions with the type system in a way which is fully decoupled from our eventual verification language and goals.

In this internship, we plan to explore three main objectives. Firstly, we will extend this elaboration of a Rust program to support the interaction between struct type definitions and lifetime parameters in a general way, which is not possible in our current approach. Secondly, we will develop an encoding to reconnect this elaborated representation to the Viper verification infrastructure (ideally supplanting the existing codebase). Thirdly, we will consider at least one alternative/variant encoding of the Rust program into Viper, to demonstrate the flexibility of our new model and its independence from the backend approach.

The project affords opportunities to learn and practice Rust programming, and to gain familiarity with type system features, compiler design and program verification. Prusti is a collaboration between several faculty and students, and this project will include exposure to the wider research directions of the project and the chance to collaborate with and present ideas to a large research team.

Experience with Rust and (ideally) formal reasoning or proofs is desirable.

 

Alexander Summers

Automated Testing of Haskell Compiler Rewrite Rules

Optimizing compilers employ a number of techniques that transform code to yield the same result with better runtime characteristics. To support such optimizations, the Haskell programming language (as implemented in the Glasgow Haskell Compiler, GHC) allows library authors to implement their own compile-time optimizations in the form of rewrite rules. Many well-known Haskell libraries make heavy use of rewrite rules to achieve better runtime performance. 

However, incorrect rewrite rules (those that define invalid program transformations) are difficult to debug and can change program behaviour in unexpected ways. Unfortunately, in general, there is no easy way to test Haskell rewrite rules for correctness.

In recent work we developed a first prototype tool, Rulecheck, that automatically generates and executes property-based tests for Haskell rewrite rules, with the goal of identifying incorrect rules in real-world Haskell libraries. Although we have developed a proof-of-concept, there is still much more work to be done; in particular, we have the following next aims for this research internship:

1. Extend Rulecheck to support a wider range of Haskell type system features

To test a rewrite rule, Rulecheck must generate well-typed Haskell expressions that match the arguments of the rule. Due to the expressiveness of Haskell's type system, this is not trivial. Our prototype tool only supports a subset of Haskell types; and therefore cannot generate expressions for some rewrite rules (for example, those operating on expressions with higher-kinded types). Extending Rulecheck to support more of Haskell's type system will enable more rewrite rules to be testable, and improve Rulecheck's ability to find bugs.     

2. Reduce the rate of false positives in generated tests

The tests generated by our current implementation of Rulecheck sometimes fail, even when the underlying rewrite rule is correct. For example, some test failures occur because Rulecheck automatically generates expressions that would never be actually used in the application of a rule. Manual analysis is necessary to determine if test failures correspond to actual issues. We would like to reduce the amount of manual intervention required, by generating better tests in the first place.

3. Evaluate Rulecheck against real-world Haskell libraries

Rulecheck is intended to test the rewrite rules in real-world Haskell libraries; as yet, we have only used Rulecheck on a handful of libraries. However, Hackage (the Haskell package repository) contains over 100 libraries that define rewrite rules. To prove the efficacy of our technique, we would like to apply Rulecheck to these libraries; identifying incorrect rewrite rules and reporting any problematic rules to library authors. Doing so will likely require extending Rulecheck to support a wider range of Haskell language features.

The project affords opportunities to learn and practice Haskell programming, and to gain familiarity with property-based testing, advanced type system features and compiler design. In addition, this project will provide experience working on a research project in collaboration with other faculty and students.

Ideal candidates for this project should have an interest in functional programming. Previous experience with Haskell and QuickCheck is a plus.

 

Alexander Summers

Reengineering a Debugger for Quantifier Reasoning in SMT

SMT solvers have a wide variety of applications across Computer Science, including program analysis and synthesis tools, automated planning and constraint solving, optimisation problems and software verification. Advanced tools such as program verifiers are often built around SMT encodings of their problems. However, designing these encodings to perform reliably and fast is a challenging task. In previous work, we developed the Axiom Profiler tool to serve as a first debugging tool for quantifier-rich SMT problems. While vastly more useful than trying to debug by hand, this tool has a number of limitations in practice, and requires a substantial redesign and reimplementation with the following objectives:

  1. Build an application with a modern and OS-independent GUI, capable of mixing both simple button-press interactions with more-sophisticated functionality for navigating graph visualisations.
  2. Design a modular, maintainable codebase in a suitable programming language, so that the tool can be robustly developed in the future.
  3. Understand and reimplement the core analysis algorithms which support user navigation and explanation of the information visualised.
  4. (optionally) interact with modern proof logging formats as generated by newer versions of the Z3 SMT solver.
  5. (optionally) consider how the profiler can be generalised to debug runs of other SMT solvers (if possible).

The project affords opportunities to learn about formal reasoning and the automation of logical proofs using state-of-the-art SMT solvers. Prior experience with GUI application development, algorithms, SMT Solving and/or formal reasoning would all be advantageous but not necessarily essential; good analytical skills and expertise with imperative programming of some kind are needed.

 

Alexander Summers

Applying the Prusti Verifier to a Rust model of an AWS File System

The Prusti project (a collaboration between UBC and ETH Zurich) aims to provide modular, code-level verification tools for Rust, a modern systems programming language. The combination of Rust's advanced ownership type system and user-defined specifications makes it possible to provide scalable and efficient formal verification for a wide variety of program properties, including allowing programmers to express their intentions and check that their code will always live up to these.

In discussions with collaborators at AWS, we have a greatly-simplified model of a file system they are developing; as part of their software engineering process they are building models of the eventual systems at various degrees of accuracy/complexity all in Rust: each version of the models is designed to behave similarly to the previous, but with more efficiency/real-world concerns added. At the simplest end, there is a sequential implementation of various core data structures and algorithms relevant for the file system’s unique design. Verifying desirable properties even of this simplest model is potentially of value in such a design process, since any bugs in these simplified models would likely persist in the more-complex variants of the software.

In this project, we will investigate the application of Prusti to this file system model as a case study. We will consider a variety of desirable properties, ranging from simple panic (crash) freedom, to data structure invariants and potentially even to crash-consistency properties that show that data will be recovered during unexpected failures. Depending on the outcomes of our first experiences using Prusti on this codebase, we may develop additional features in the Prusti tool itself to make this kind of verification more direct, easier or more efficient. If we are successful at verifying one model, we might also consider the challenges involved in working with a more accurate software model including concurrency, and how to relate the two versions.

This project offers experience with system design and formal verification, as well as experience with Rust and modern verification tools. Prior experience with Rust and/or formal reasoning about programs are advantageous but not essential; expertise with imperative programming of some kind is needed.

 

Alexander Summers

A DSL and Query Engine for Large-Scale Analysis of Open-Source Rust Code

Rust is a rapidly-growing systems language attracting ever-growing interest from engineers and researchers alike. There is already a huge corpus of open-source Rust software available via the crates.io standard repository. This collection of real-world software is a rich source of information about how developers are using this new language in the wild. For example, in a recent paper, “How do Programmers use Unsafe Rust?”, we performed an empirical evaluation of the entirety of this corpus to answer a number of questions about the “unsafe” features of the Rust languages, and how they are actually employed in the wild.

To perform this analysis, we developed infrastructure called “qrates” for assembling a database of facts related to the available online repositories and presenting these facts for analysis in Jupyter notebooks. However, the information extracted into this database was specific to the empirical study in question, and changing (or even refining slightly) the information extracted over the corpus of software projects is currently a manual process. Rerunning this database extraction process is also cumbersome and requires excessive computing power, since all information is temporarily stored in memory, making it difficult to scale this work up to the increasingly huge amount of open-source Rust code available online.

In this project, we will aim for a generalisation and reengineering of the qrates approach and tools, with the following objectives:

  1. Design a query DSL suitable for defining the desired facts to be assembled into a database, as well as the selection of which Rust projects (crates) should be included. This should make it possible to assemble multiple different databases without making manual changes to the qrates code itself.
  2. Reengineer the underlying qrates framework to support pluggable queries via your newly-developed DSL, and to avoid the current need to hold all data in memory; supporting concurrency in the assembly of the database would also be interested to explore.
  3. Evaluate possible technical solutions for deploying the qrates framework via either cloud computing or dedicated server solutions, so that evaluation can be performed remotely by users of typical computing hardware (for example, we might setup a specific machine to run these corpus evaluation workloads).
  4. Demonstrate the usability and flexibility of the new framework by both rerunning prior evaluations and running new ones over the current corpus of Rust crates.

The project affords opportunities in language design and implementation, remote computing and concurrency in a practical setting, as well as programming experience in Rust. Prior experience with Rust and database / query languages or other data analysis frameworks would be advantageous.

 

Helge Rhodin

3D Gaze Estimation for View-Dependent Display

Eye contact and gaze are significant components of in-person interactions which are difficult to simulate virtually. Often, a monocular view of a RGB video stream is limited in portraying the dimensionality of a 3D object - the viewer can only observe the object in a fixed position and changing the head's position and orientation of the viewer will not result in varying perspectives of the object being viewed. 

By using a head-mounted display (HMD)'s built-in tracker or other means of head position and orientation trackers, one could calculate the view direction of the user and simulate the view[1]dependent rendering by varying the virtual camera's position and orientation. However, this would require the purchase and possession of such devices, while equipping the devices may serve as an intrusive barrier in virtual communications. 

In this project, the student will aim to create a deep-learning based solution for gaze estimation from a consuler-level depth camera, in particular the 3D calibration of the camera, display, and user position. Building upon previous works on 3D gaze estimation and view-dependent rendering, the goal is to build a real-time 3D view-dependent display based on an RGBD camera input. The software will serve as a non-intrusive addition to telecommunication and aid in an immersive 3D interaction experience.

 

Nick Harvey

Design and analysis of randomized algorithms

Many of the tasks performed by modern computers involve randomization. Examples include estimating properties of a data set by sampling, or privatizing aspects of a data set by adding random noise. 

One of the simplest examples of such a task is drawing a random sample from an array without replacement. The standard approaches for this task either require modifying the array, or require an auxiliary hash table data structure. The former is undesirable in many settings, such as multi-threading environments; the latter can involve quite a lot of overhead and may lack provable guarantees. In this research, we aim to explore simple, efficient approaches to this problem that still have provable guarantees. 

This project offers experience with mathematical proofs, tools from probability theory, reading relevant research papers, and an opportunity to write a research paper.

Strong performance in CPSC 436R (Introduction to Randomized Algorithms) and honours mathematics courses is required.

Summer 2022

Margo Seltzer

Think Like an Edge or Think Like a Vertex?

Graphs are near-ubiquitous for representing information and there's a pressing need to create systems that can store and process larger graphs, more quickly. Most such systems are based on the Bulk Synchronous Parallel (BSP) computing paradigm and the many processing paradigms derived from it. In most of these models, the overall graph computation (e.g., performing BFS or computing PageRank) is decomposed into many steps, each of which might be separated by a barrier phase. Each step performs a single iteration of the algorithm on a subset of the graph; in the barrier phase, the results of these sub-computations are collated and propagated to the next subset of the graph. This process is repeated several times until the results converge.

Several graph processing systems define superstep computations in terms of "Vertex Programs" — Other systems define these computations in terms of "Edge Programs" -- computations performed on each edge of the graph. These two approaches are interchangeable in terms of the correctness of the decomposition involved but can have significant impact on the time needed for completion. Most systems select either a vertex-centric or an edge-centric system deep in the design of the system, which means that it is practically impossible to fairly compare them. More importantly, there is no (as far as we know) heuristic to decide which paradigm might perform better for a given workload (algorithm) and dataset.

This project is about deciding which style of computation - edge-centric or vertex-centric - performs better for a given workload + dataset. We have developed a system that lets us experiment with different styles of processing large graphs, and we want to conduct an empirical study to develop guidelines for which processing model is better suited to different scenarios.

This project provides a good opportunity to learn about parallel software architecture (i.e., if you really liked CPSC 418 by Prof. Greenstreet or really want to take it) and how to design large scale data processing systems.

Margo Seltzer

Introspection in Dynamic Graph Processing

Dynamic graphs are graphs that are subjected to the addition and deletion of edges and vertices. These systems are important as most real-world applications such as social networks or web graphs are constantly changing. There are many different systems for processing dynamic graphs, but it is difficult to figure out which of these systems is better for any particular task. More fundamentally, it is nearly impossible to figure out why one system is faster/slower than another system for a given workload. Results in publications are inconsistent!

This project is about developing tools, techniques, and evaluation platforms that provide deep introspection of these systems. We want to answer research questions such as: 1- Is there any way to measure the performance of analytic tasks with a small set of micro-benchmark results or graph metrics,  e.g, get_common_neighbours(x,y), get_neighbours(x), or measure betweenness centrality? 2- Can we construct an interpretable model for identifying the best system for a particular algorithm, dataset, and hardware configuration? 3- Can we generate add/delete queries based on real-world recognized behaviours on real-world dynamic graphs (e.g., Twitter Graph)? 4- How do different systems utilize hardware resources in their computation (Memory Footprint, Cache usage)?

The research will involve both theoretical and empirical work.

Margo Seltzer

Hardware modeling meets an SMT Solver

Translation hardware units (such as MMUs) provide isolation and protection to software; these components are security critical! The Velosiraptor project’s goal is to formally describe translation hardware in a domain specific language, from which we can automatically synthesize software and/or hardware.

Instead of manually writing (potentially buggy) code to interface between software and translation hardware, programmers write a specification of the translation semantics. We then have developed a tool chain that then automatically produces the corresponding code. While this works well on in some cases,  we want to determine whether other approaches using more domain knowledge could lead to better results.

In this project, we wish to remove one tool from our tool chain and instead translate directly from our domain specific language into a format that can then be fed into the Z3 theorem prover. This should give us more control over the synthesis process. We will begin by exploring how to encode our specifications and express constraints that can be interpreted by Z3.

Margo Seltzer

The Velosiraptors in the Kernel

Translation hardware units (such as MMUs) provide isolation and protection to software; these components are security critical! The Velosiraptor project’s goal is to formally describe translation hardware in a domain specific language, from which we can automatically synthesize software and/or hardware.

Instead of manually writing (potentially buggy) code to interface between software and translation hardware, programmers write a specification of the translation semantics. We then have developed a tool chain that then automatically produces the corresponding code. In this project we wish to generate code that can be integrated into an operating system. This involves adapting the code generation backend to the architecture-specific parts of the OS kernel (e.g., Linux or Barrelfish) that interface with translation hardware (e.g., the MMU or IOMMU). The goal is that we can replace parts of the OS code with the synthesized variants.

Margo Seltzer

Diving into Device Drivers

Device drivers are one of the largest sources of bugs in today’s systems! This project is part of a larger effort to assemble device drivers from a collection of small building blocks. Specifically, we're trying to identify and classify the interactions of existing drivers with the rest of the operating system/kernel: what subsystems functions are used  and how. The goal is then to have a model that expresses device drivers in terms of these functions and ultimately, make it possible to easily port a driver from one system to another.

Margo Seltzer

Dafny, meet GOSDT; GOSDT, meet Dafny.

GOSDT is an algorithm and implementation for producing a provably optimal decision tree with respect to a regularized loss function and data set.  GOSDT is based on a (large) collection of mathematical theorems, but we have no proof that the code correctly implements each of these theorems.  Dafny is a  verification aware programming language that makes it possible to prove that an implementation correctly implements a specification. If we could re-implement GOSDT in Dafny, we could directly connect the mathematical theorems to the implementation. This would be ground breaking work!

* Students will be developing software in Dafny.

* Students will be expected to read and discuss research papers, with our guidance and support.

* Students will be part of the Systopia lab, which holds weekly reading groups, skills development sessions, and social events as public health allows.

* Students will have at least one group meeting per week with the faculty advisor and will have a direct graduate student or Postdoc mentor

* Students will also participate in a Zoom-based weekly meeting with collaborators at Duke University

Dongwook Yoon

Enhancing Pull Request Interface with Interactive Referencing Features

A design concept of typed-referencing in our Pull Request tool. 

The productivity of software engineering practices are increasingly dependent on the efficacy of cooperative work between multiple stakeholders. Pull Request (PR) is an important software development lifecycle tool that these stakeholders use to contribute changes, feedback, and suggestions into their shared software codebase. Discussing a PR involves referring to the code changes within the PR itself and also the underlying context (e.g., who made the changes, for what, associated documentation, system logs, etc.). It is time- consuming and error-prone for developers to refer to and understand such contextual system elements embedded in the textual discussion threads. To save developer time and prevent potential miscommunication, we need a better PR interface that helps the stakeholders create and access the references around the PR. Our approach is to make the references interactive and recommended. To this end, we will design and build a new traceable PR discussion interface as a browser plugin.

Qualifications

  • Strong technical skills including OOP, data structures, and algorithms.
  • Experience in web front-end web development
  • Interested in studying human collaboration in software development (e.g., conducting interviews, analyzing data about software development projects, etc);
  • (optional) HCI design skills or successful completion of the introductory HCI courses (e.g., CPSC 344)

Dongwook Yoon

Designing for Fair Payment and Reducing Invisible Labor in Online Freelance Work

Online freelance platforms, such as Upwork, support millions of business tasks to be completed by workers from the globe. While Upwork provides freelancers with flexibility in managing their schedule and making supplemental income, freelancers also experience a large amount of unpaid work which are often invisible to their clients. This is particularly the case for novice freelancers, who need more guidance in securing fair work while building reputation. To support novice freelancers, based on our qualitative insights, we design interfaces with novice freelancers to 1) identify jobs and practices that lead to excessive unpaid work; 2) communicate the unpaid work to the client while maintaining the freelancer's relationship with the client and their reputation. We evaluate the designed prototype with clients and freelancers to understand its efficacy in supporting freelancers reducing unpaid work and clients’ receptance.

Qualifications:

  • Strong HCI design skills or successful completion of the introductory HCI courses (e.g., CPSC 344)
  • Strong verbal and written communication skills and ability to independently conduct user interviews and design evaluations
  • (Optional) Experience in web development

Dongwook Yoon

AI-augmented Video Interfaces

This project aims to build and evaluate an AI-augmented interface to improve viewers’ experience in video-based learning. Despite the abundance of educational content on online video platforms, such as YouTube, the platforms are short of providing ways for the learners to regulate their learning process, such as semantic exploration of videos, an agent-based learning guide, and mediated social interaction between learners/instructors. We will employ an ensemble of AI techniques, such as computer vision, speech recognition, and natural language processing to develop intelligent support for navigating, browsing, authoring, and annotating video content.

Qualifications:

  • Strong technical skills including OOP, data structures, and algorithms.
  • Experience in building computer vision, speech processing, and/or natural language processing applications
  • (optional) Experience in web front-end web development

Andrew Roth

Cancer is a complex disease driven by genetic mutations that follow an evolutionary process. This evolutionary process produces genetically distinct populations of cells which can be analyzed over time to evaluate treatment efficacy or detect minimal residual disease (MRD). Liquid biopsies are an emerging minimally invasive sampling method that allows for serial sampling. They contain samples of biological fluid (e.g. a blood sample) that contain DNA fragments known as cell-free DNA (cfDNA). Importantly, liquid biopsies of cancer patients contain tumour-derived DNA fragments, called cell-tumour DNA (ctDNA), which yields genetic information about the cancer itself and have the potential to direct personalized cancer care.

The successful applicant will work alongside Dr. Roth and his graduate students on a Bayesian model to both estimate the relative proportions of existing clones, and discover emergences of novel clones over time. This model will elucidate the temporal heterogeneity of clonal populations, enabling practitioners to make informed treatment decisions to combat resistance, metastasis, or recurrence in cancer.

The student will help implement bioinformatic pipelines for processing high throughput sequencing data and gain familiarity with state-of-the-art Bayesian modeling techniques based on Markov Chain Monte Carlo (MCMC) and Variational Inference (VI) utilizing Probabilistic Programming Languages (PPLs) such as Pyro and PyMC3. Students with a strong computational background in Computer Science and/or Statistics would be great candidates; at least one course in probability (e.g. STAT 302) and basic programming (CPSC 210) are required. Experience in bioinformatics and machine learning with Python and R would be valuable assets.

Jiarui Ding 

Developing Effective Visualization Methods for Large-Scale High-Dimensional Data

Visualizing large-scale high-dimensional data is essential for developing better machine learning algorithms and for data science. Currently, t-SNE and UMAP are wildly used for visualizing high-dimensional data. Although the t-SNE objective function is widely used, it may not be ideal for visualizing the cluster structure. The research objective of this study is to investigate different objective functions for better visualizations. For testing, we will use classic datasets such as MNIST and large datasets from the single-cell genomics field, e.g., scRNA-seq data. The student will learn currently widely used data-visualization tools for machine learning and data science, get the hands-on experience of using GPUs for research, and will be well-equipped for further study and research in the field of dimension reduction and single-cell genomics.  

Jiarui Ding

Graph Neural Network to Analyze Spatial Transcriptomics Data

In model machine learning and data science, we have datasets in different formats. One example is the spatial transcriptomic data that can be naturally described as a graph. The problem is how to develop more tailored graph neural networks for such data. The student has the opportunity to explore the frontier of single-cell genomics and graph neural networks for knowledge discovery. 

Jiarui Ding

Single-Cell Studying of Esophageal Conditions 

If you want to develop computational algorithms to better understand human diseases, this is a perfect project for you. Here we will study esophageal cancer, Barrette’s esophagus, and chronic acid reflux using single-cell genomics. The student will learn the best practice for single-cell RNA-seq data processing and uses/extends powerful deep generative models for integrating data from different conditions/sources and/or modalities to better understand the disease tissue microenvironment.   

Jiarui Ding

Learning Disentangled Representations 

If you have a strong background in statistical modeling and latent variable models and want to look for some challenging problems, this is a project for you. Although you may hear of disentangled representations, this project is different, and we will explore some special properties of our data and also other approaches that have not been explored for learning disentangled presentations.

Karon MacLean

Predictive Models of Real-time Affective Touch 

Building a computational model of human emotions is difficult, and raises philosophical and engineering questions about what emotions are and how we can capture them through behavioural and biometric signals. Current efforts in computational emotion modeling use simplistic machine learning classification schemes (i.e., recognize “happy” or “sad”), poor behaviour classification schemes, and ignore context (i.e., a smile could imply friendliness or sarcasm depending on context). Our goal is to create more complex emotion models using machine learning techniques on affective touch. We target (1) identifying transitions between emotion states; and (2) incorporating contextual data into personalized models to inform classification schemes. In conjunction with a team of grad students, the student researcher will help to develop a process for building dynamic personalized machine learning models. These models will be built into a system that classifies emotion transitions from touch data collected through an emotion recall task.
Qualifications:

  • Experience with real-time machine learning applications
  • Strong interest in/knowledge about the projects currently being conducted at SPIN lab. 
  • Strong technical skills including OOP, data structures, and algorithms.
  • Strong verbal and written communication skills and ability to independently conduct user interviews and design evaluations
  • (optional) HCI design skills or successful completion of the introductory HCI courses (e.g., CPSC 344)

Contact: Laura Cang ; Rubia Guerra 


Karon MacLean

Web application for Predicting and Interpreting Real-time Affect

Figure 1. Screenshots of the final design of the interface in low fidelity.

UBC SPIN lab is examining affective, responsive touch, in contexts including haptic robots and handheld objects such as pliable, actuated mobile devices. We have already established validated evidence of recognizable affective patterns in how people touch objects. 

We are currently working to recognize patterns in users' touch to drive affective interaction design, with sensing that is less intrusive than physiological sensors. Our work centers around a custom haptic therapy robot where applications include pediatric and adult therapy for anxiety, autism and other emotion disorders; and more broadly, designing responsiveness into touched objects. In order to provide useful emotion information to emoters and/or caregivers, we are building a system that allows for dynamic prediction editing and label correction. In conjunction with a team of grad students, the student researcher will develop a web-based application that allows study participants to visualize results of a real time prediction engine and edit machine-generated emotion labels as defined by a pre-validated interface. This work is proceeding in coordination with ongoing graduate research on personalized real-time touch classification using advanced machine learning techniques, and robot prototyping.
 

Qualifications:

  • Experience in front-end web development 
  • Strong technical skills including OOP, data structures, and algorithms.
  • Strong verbal and written communication skills
  • (optional) Experience in end-to-end application development. Framework flexible but preference for experience with HTML/CSS/Javascript, git (or any version control repository), C++, Python, or Java 
  • (optional) HCI design skills or successful completion of the introductory HCI courses (e.g., CPSC 344)

Contact: Laura Cang ; Rubia Guerra 


Kevin Leyton-Brown

Designing Efficient Algorithms

Designing efficient algorithms for solving the Boolean satisfiability (SAT) problem is crucial for practical  applications such as scheduling, planning, and software testing. Machine learning is an important tool in algorithm design for SAT, however SAT practitioners have yet to exploit the representational power of deep learning. We propose to train a neural network to learn to make variable ordering decisions for the widely used  CDCL-style SAT solvers.

CDCL SAT solvers search for a solution in a tree-like fashion, where decisions are made to iteratively partition the search space. Existing heuristics for deciding how to partition the search space don't use machine learning to leverage the structure of the internal solver state. We propose to use Monte-Carlo Tree Search (MCTS) reinforcement learning to train a neural network policy to map from internal solver state to partitioning decisions in order to minimize the number of steps required to prove SAT/UNSAT.  

To date, we have achieved a working implementation with promising performance gains on small-size SAT distributions. The student will join in to help us scale up our method to work on larger and more difficult SAT distributions. They will work on (1) improving efficiency of Monte-Carlo tree search for generating training data by sharing data across similar instances; (2) training neural networks to learn policies for a CDCL SAT solver, (3) amortizing cost of queries to neural nets over many consecutive decisions, and (4) leveraging existing solvers for small subproblems where a neural network solution is too slow.

The student will work closely with Leyton-Brown's graduate students. They have primary responsibility for well defined tasks (usually implementing aspects of a system, running computational experiments, and analyzing the results) but also often get involved in problem (re)formulation and generating new research ideas.

Qualifications:

The student should have a basic understanding of machine learning concepts and should be competent in C++ (for SAT solver) and Python (for ML). Knowledge of deep learning (pytorch), cluster computing, statistics, and CDCL SAT solvers will be an asset.

Please contact Chris Cameron at cchris13@cs.ubc.ca if interested and to set up a time to talk.

Alexander Summers 

Specification Resolution for Polymorphic Features of the Rust Type System

The Prusti project (a collaboration between UBC and ETH Zurich) aims to provide modular, code-level verification tools for Rust, a modern systems programming language. The combination of Rust's advanced ownership type system and user-defined specifications makes it possible to provide scalable and efficient formal verification for a wide variety of program properties, including allowing programmers to express their intentions and check that their code will always live up to these. Prusti supports equipping Rust program functions with specifications (formal pre- and post-conditions) as annotations attached to a function declaration; those same specifications (along with Prusti’s translation of the ownership aspects of the Rust type system) provide a means of reasoning modularly about calls to the function (reasoning in terms of the specification rather than the function’s body).

However, in the presence of traits, multiple specifications can be relevant for a particular function call: those attached to its declaration in known-implemented traits, as well as though attached at its implementation. Resolving an appropriate effective specification for such calls becomes correspondingly trickier, although initial support for such scenarios is implemented. Once one incorporates Rust’s (bounded) polymorphic types, type members, and alternative implementations, the appropriate set of rules is harder still to pin down. In this project, we aim to develop a clear set of rules for resolving usages of functions (and other program members) to corresponding specifications. Furthermore, we will design and implement a clean, separate phase of the Prusti verifier which implements these rules and (via appropriately designed programmatic representations) assembles the information required to make specification resolution straightforward for later stages of the verifier’s implementation.

The project affords opportunities to learn and practice Rust programming, and to gain familiarity with type system features, compiler design and program verification. Prusti is a collaboration between several faculty and students, and this project will include exposure to the wider research directions of the project and the chance to collaborate with and present ideas to a large research team.

Alexander Summers

Enriched Rust Program Representations for Program Analysis and Verification

The Prusti project (a collaboration between UBC and ETH Zurich) aims to provide modular, code-level verification tools for Rust, a modern systems programming language. The combination of Rust's advanced ownership type system and user-defined specifications makes it possible to provide scalable and efficient formal verification for a wide variety of program properties, including allowing programmers to express their intentions and check that their code will always live up to these. Prusti performs verification of Rust programs via translation from a Rust compiler intermediate representation (MIR) into a program in a different intermediate verification language (Viper). This translation is performed after type and borrow-checking, and heavily depends on and exploits Rust’s ownership type system: in practice Prusti extracts information from a number of static analyses and interfaces from the compiler.

However, Prusti’s translation current intertwines Rust-level concerns (extracting compiler analysis information), with Viper-level concerns (how Rust language features are ultimately embedded into Viper, modelled and reasoned about). This makes explaining and formalizing the conceptual model behind the verification difficult, extending the translation more-challenging than needed, and makes the code impact of (frequent) changes to unstable compiler APIs much greater than necessary. In this project, we’ll collaborate with other members of the Prusti team to design a new intermediate representation of a Rust program, elaborated with full information from the compiler to explain why and how type and borrow-checking were successful. We’ll implement new translation stages which cleanly separate the Rust/compiler-related aspects from the underlying Viper translation, enabling a new core verification path for the tool.

The project affords opportunities to learn and practice Rust programming, and to gain familiarity with type system features, compiler design and program verification. Prusti is a collaboration between several faculty and students, and this project will include exposure to the wider research directions of the project and the chance to collaborate with and present ideas to a large research team.

Alexander Summers

Enhanced Verification Support for Rust Slices and Pointwise Specifications

The Prusti project (a collaboration between UBC and ETH Zurich) aims to provide modular, code-level verification tools for Rust, a modern systems programming language. The combination of Rust's advanced ownership type system and user-defined specifications makes it possible to provide scalable and efficient formal verification for a wide variety of program properties, including allowing programmers to express their intentions and check that their code will always live up to these. Prusti includes basic support for reasoning natively about Rust’s array and slice types, the latter of which provides a type-representation for a partial version of the underlying data structure.

Verification of programs manipulating such slices must combine the ability to specify and track values potentially modified via a slice type, while preserving for free (“framing”) information about other disjoint portions of the underlying data. Encoding these verification requirements in ways which can be automated with decent performance raises many challenges, due to the prevalence of logical quantifiers in the underlying conditions. In addition, many useful functional specifications of such programs require comprehensions of data structure contents (sums, sets, sortedness properties, and the like), which present further challenges for specification and automation. In this project we will design and implement several extensions to Prusti’s existing support for slices, and apply the new support to verify important algorithmic examples such as sorting functions.

The project affords opportunities to learn and practice Rust programming, and to gain familiarity with type system features, compiler design and program verification. Prusti is a collaboration between several faculty and students, and this project will include exposure to the wider research directions of the project and the chance to collaborate with and present ideas to a large research team.

Summer 2021

Ian M. Mitchell

Project 1. Software development, motion modeling, sensor integration, collaborative control scheme design, and testing for a highly dynamic ground robot

There are many types of vehicles and applications for which it may be desirable to share control between a human and robot.  The Verification, Control and Robotics (VCR) lab has worked with a shared control powered wheelchair platform for many years, but is now developing a testbed based on small, fast autonomous race cars (specifically the NVIDIA Jetracer).  The goal of this project is to continue development of this testbed, which will (a) reduce the overhead of running user studies on new shared control strategies compared to the cumbersome wheelchair platform and (b) allow us to compare and contrast the requirements and possible solutions to these two very different shared control use cases.

The student will learn ROS (the robot operating system) and the basics of human subject trials (including the TCPS2 CORE).  The student will work with one or more graduate students to identify and/or learn a model of racer motion; integrate sensors into the system; build a robust and flexible version of the shared control software and/or design a shared conrol interface.  Many of the subprojects could be completed remotely if the pandemic situation makes lab access infeasible.  The faculty supervisor has extensive experience training undergraduate student researchers -- including 23 in the past five years -- and the primary doctoral student supervisor previously held an NSERC USRA in the VCR lab before starting his graduate studies.

Applicants must be comfortable with C++, and will be expected to learn and use ROS (robot operating system) to control the vehicles.  Applicants should be prepared to work independently, to express themselves clearly in discussions, and to give at least two brief presentations to the research group.

Familiarity with machine learning (such as CPSC 330 or 340), computer vision (such as CPSC 425), human-computer interaction (such as CPSC 344), computational optimization (such as CPSC 406), parallel programming (such as CPSC 418), system identification, electronics, mechatronics or autonomous vehicles would be useful for some but not all potential subprojects.  It is expected that applicants may know few if any of these optional topics.

Update: The position has been filled.

Aastha Mehta

Project 1. PanCast: Listening to Bluetooth Beacons for Epidemic Risk Mitigation

Contact tracing is an important part of an epidemic mitigation strategy. During the ongoing COVID-19 pandemic, there have been burgeoning efforts around the world to develop and deploy smartphone apps to expedite contact tracing and risk notification. These apps rely on various technologies ranging from QR-code scanning to GPS tracking and pairwise Bluetooth exchanges between individuals in prolonged proximity of each other. Unfortunately, these apps have not yet proven to be sufficiently effective due to low adoption rates, privacy concerns, and low accuracy in predicting infection risk. Indeed, B.C. has not adopted the Candian national COVID Alert app due to some of these very reasons.

We propose PanCast, a privacy-preserving and inclusive system for epidemic risk assessment and notification that scales gracefully with adoption rates, utilizes location and environmental information to increase utility without tracking its users, and that can also be effective in identifying superspreading events. To this end, PanCast utilizes Bluetooth encounters between beacons placed in strategic locations (e.g., where superspreading events are most likely to occur) and inexpensive, zero-maintenance, small devices that users can attach to their keyring. PanCast allows healthy individuals to use the system in a purely passive "radio" mode, and can assist and benefit from other digital and manual contact tracing systems. Finally, PanCast can be gracefully dismantled at the end of the pandemic, minimizing abuse from any malevolent government or entity.

To know more about the project, visit https://pancast.mpi-sws.org/. You can participate in this project by getting involved in building a prototype of the PanCast system using Bluetooth devices and a deployment of the system in a small part of the university campus. If you are interested, reach out to aasthakm@cs.ubc.ca.

 

Alex Summers

Project 1. Extensible parsing and type-checking for Prusti

The Prusti project (a collaboration between UBC and ETH Zurich) aims to provide modular, code-level verification tools for Rust, a modern systems programming language. The combination of Rust's advanced ownership type system and user-defined specifications makes it possible to provide scalable and efficient formal verification for a wide variety of program properties, including allowing programmers to express their intentions and check that their code will always live up to these.

Prusti’s specification language includes a large subset of Rust itself, but adds additional features such as logical quantifiers and connectives. This creates a tension in the handling of parsing and type-checking of specifications: to avoid duplicating unnecessary code we would like to reuse the compiler’s existing parser and type-checker, but this cannot be applied to specifications in general. The current solution implemented leads to ad hoc restrictions and can cause poor error reporting for incorrect inputs

Tasks: In this project you will develop and implement an approach for parsing and type-checking a generalisation of Prusti’s current specification language, allowing for inputs which mix and match both Rust statements and Prusti-specific features while simultaneously reusing the Rust compiler’s existing codebase for parsing and type-checking the Rust aspects of the input. If successful, this will provide a significant improvement to the generality and usability of the Prusti verifier.

Qualifications: Prior experience with Rust and/or compiler implementation are advantageous but not essential; expertise with imperative programming of some kind is needed.

Project 2. Automated Debugging for SMT Solving

SMT solvers have a wide variety of applications across Computer Science, including program analysis and synthesis tools, automated planning and constraint solving, optimisation problems and software verification. Advanced tools such as program verifiers are often built around SMT encodings of their problems. However, designing these encodings to perform reliably and fast is a challenging task. In recent work, we developed the Axiom Profiler tool to serve as a debugging tool for quantifier-rich SMT problems.

Tasks: In this project, you will work to extend the Axiom Profiler to provide new automated techniques for helping a user to zoom in on, diagnose and solve inadequacies in their SMT encodings.

Qualifications: Prior experience with SMT Solvers, visual tools and/or formal reasoning is an advantage, but is not essential; expertise with imperative programming of some kind is needed.

Project 3. Sufficient preconditions for panic-freedom of Rust functions

The Rust programming language is a relatively-new systems language, designed to be a more-robust alternative to C++ and similar languages. The Prusti project (a collaboration between UBC and ETH Zurich) aims to provide modular, code-level verification tools for Rust, allowing programmers to attach specifications to functions describing e.g. how they should be called (preconditions). An important property of Rust code is panic-freedom: a “panic” in Rust is a runtime exception, and one would typically like to rule out such program behaviours at compile time. Prusti offers to possibility to statically prove that *for calls to a function satisfying its precondition*, the function’s body cannot cause panics. In general, however, this requires annotating functions with preconditions strong enough to rule out potential panics.

Tasks: In this project, we will first analyse existing codebases (published on crates.io) to identify how many functions can already be proven panic-free by Prusti with no preconditions (for example, because if-conditions in the code conservatively check for problematic cases before a panic can be caused). For the remaining functions, we will investigate how complex and difficult (or not) the task is of providing sufficient specifications for Prusti to be able to show panic-freedom. As a result, we should understand better the question of how rich a function’s specification needs to be in practice to at least eliminate these basic kinds of runtime errors.

Qualifications: Prior experience with Rust and/or compiler implementation are advantageous but not essential; expertise with imperative programming of some kind is needed.

Project 4. A standard library for Rust verification

The Prusti project (a collaboration between UBC and ETH Zurich) aims to provide modular, code-level verification tools for Rust, a modern systems programming language. The combination of Rust's advanced ownership type system and user-defined specifications makes it possible to provide scalable and efficient formal verification for a wide variety of program properties, including allowing programmers to express their intentions and check that their code will always live up to these. Prusti’s verification is function-modular, meaning that calls to other functions are reasoned about via their specifications; for this reason, it’s necessary to provide good specifications for commonly-used standard library functions.

Tasks: In this project, we will work on equipping as much of the Rust standard library as possible with suitable Prusti specifications. This will exercise some relatively new features of the verifier, and will likely uncover the need for further extensions. Furthermore, we’ll investigate whether it’s clear that a single specification is suitable/convenient for all clients of a library, or whether we need support for specifications of different levels of complexity, depending on the usage and application.

Qualifications: Prior experience with Rust and/or formal reasoning about programs are advantageous but not essential; expertise with imperative programming of some kind is needed.

 

Dongwook Yoon

Project 1. Ethics in Human Surrogates and Virtual Humans

Human surrogates (HSs, a.k.a virtual humans), what was once a sci-fi fantasy, is becoming a reality thanks to advances in deep fake, speech synthesis, and robotics technology. A virtual reunion of a South Korean mother and a virtual recreation of a deceased daughter was a particularly dramatic event. While many of these efforts are well intended, there are unforeseen blind spots that could cause dire consequences. A recent example being the fake Obama speech video created using AI video tools. While these advances push the boundaries of technology, we know very little about its unintended and long-term implications to individuals and society. It is quintessential to engage with the ethical issues of HSs research, asking critical research questions: How do experts and public stakeholders perceive the costs and benefits of HSs? How do we define boundaries and off limits of ethical issues in HSs? How do these users and stakeholders think of the use and adoption of HSs? Through these questions, we look to provide an ethical framework and guidelines to inform the ethical considerations for future research in HSs. We will (1) read books and research papers on technology ethics and (2) run a qualitative study interviewing researchers and practitioners in AI, Robotics, and Computer Graphics.

Qualifications:
- Passionate in ethics and equity issues in socio-technical systems.
- Ability to deeply engage with academic literature and articulate in presenting ideas
- (optional) Experience or strong interest in qualitative methods, such as conducting semi-structured interviews

Please apply by January 27. For application details please check the following link: https://docs.google.com/document/d/1iRUvK5wGmIZY7ZKeWg-XWW3P1w1qF5rfMQhnbw2IQ7Y/edit.

Project 2. Learning to Play a Song with Online Videos: Strategies and Challenges of Musical Instrument Learners

Learning to play a musical instrument by watching Youtube videos is becoming increasingly popular. Especially in situations such as the COVID-19 pandemic, playing a musical instrument is a meaningful way to spend time in isolation, as it promotes self-development and helps reduce anxiety and depression. These videos offer easy access to tutorials by expert musicians (or even the original artists, like how the famous guitarist, Carlos Santana, teaches his own song!) and diverse teaching styles (you can find an instructor who matches your taste). In this project, we will study how people learn musical expressions on YouTube and what are their specific challenges in doing so. Our findings will establish a basis for designing an intelligent interface (e.g., a browser plugin for Youtube) to help the learners find videos that are suitable for their learning styles and goals, utilize the videos effectively, and monitor their progress systematically.

Qualifications
- Successful completion of the HCI courses (e.g., CPSC 344 or 544)
- (optional) Interests in musical instruments and musical experience
- (optional) Experience in front-end web development

Please apply by January 27. For application details please check the following link: https://docs.google.com/document/d/1iRUvK5wGmIZY7ZKeWg-XWW3P1w1qF5rfMQhnbw2IQ7Y/edit.

Project 3. Enhancing Pull Request Interface with Interactive Referencing Features

The productivity of software engineering practices are increasingly dependent on the efficacy of cooperative work between multiple stakeholders. Pull Request (PR) is an important software development lifecycle tool that these stakeholders use to contribute changes, feedback, and suggestions into their shared software codebase. Discussing a PR involves referring to the code changes within the PR itself and also the underlying context (e.g., who made the changes, for what, associated documentation, system logs, etc.). It is time- consuming and error-prone for developers to refer to and understand such contextual system elements embedded in the textual discussion threads. To save developer time and prevent potential miscommunication, we need a better PR interface that helps the stakeholders create and access the references around the PR. Our approach is to make the references interactive and recommended. To this end, we will: (1) Build a taxonomy of references in PR by qualitatively analyzing diverse PR dataset available online, (2) Apply the taxonomy to a large number of PRs and identify patterns in how code elements are referenced, and (3) Design a new traceable PR discussion interface based on our empirical findings.

Qualifications
- Strong technical skills including OOP, data structures, and algorithms.
- (optional) Deep experience in front-end web development
- (optional) Successful completion of the introductory HCI courses (e.g., CPSC 344 or 544)

Please apply by January 27. For application details please check the following link: https://docs.google.com/document/d/1iRUvK5wGmIZY7ZKeWg-XWW3P1w1qF5rfMQhnbw2IQ7Y/edit.

 

Helge Rhodin

Project 1. Egocentric motion capture

In recent years, there has been tremendous progress in video-based 6D object pose and human 3D pose estimation, even from head-mounted cameras [Related work]. They can now both be done in real time but not yet to the level of accuracy that would allow the capture how people interact with other people and with objects, which is a crucial component of modeling the world in which we live. For example, when someone grasps an object or shakes someone else’s hand, the position of their fingers with respect to what they are interacting with must be precisely recovered if the resulting models are to be used in see-through AR devices, such as the Hololens or consumer-level video see-through versions.
Key to this project is the accurate modeling of contact points and the resulting physical forces between interacting hands and feet with the surrounding. The hardware setup will be a mobile head-mounted camera, building upon our egocentric motion capture work (EgoCap) [Related work]. The goal of this project is to use inertial measurement units (IMUs) and deep learning to sense ground contact and relative positions.

Related work:
EgoCap: Egocentric Marker-less Motion Capture with Two Fisheye Cameras. Helge Rhodin, Christian Richardt, Dan Casas, Eldar Insafutdinov, Mohammad Shafiei, Hans-Peter Seidel, Bernt Schiele, and Christian Theobalt. SIGGRAPH Asia 2016

Project 2. Gravity for scale estimation in multi-view reconstruction

This project aims at reconstructing objects and camera geometry by exploiting the Newton's equations of motion and gravity. Estimating metric scale from image or video recordings is a fundamental problem in computer vision and important for determining distances in forensics, autonomous driving, person re-identification, and structure-from-motion (SfM). In general, object size and distance cancel in perspective projection---which makes the problem ill-posed.
The main idea is to use the omnipresent gravity on earth as a reference 'object'. Newton's second equation of motion dictates that the trajectory of an object is a parabola, a function of time, its initial speed and position, with the curvature determined by the acceleration induced by constant external forces. This project build upon our earlier work on estimating a person’s height by relating acceleration in the image and to gravity on earth [Related work], as sketched in the inset. By contrast, the aim of this project is to use similar principles for multi-view reconstruction, for structure from motion and automatic camera calibration.

Related work:
Gravity as a Reference for Estimating a Person's Height from Video. Didier Bieler, Semih Günel, Pascal Fua, and Helge Rhodin. ICCV 2019

Project 3. Learning anthropometric constraints for monocular human motion capture

In recent years image-based human motion capture (MoCap) has progressed immensely with varying applications in e.g. movie production, sports analytics, virtual reality systems, games, human computer interaction, and medical examinations. Nowadays marketable software in these fields requires sophisticated motion capture studios and expensive measurement devices which strongly limits its applicability. This project aims to achieve human MoCap using only a single RGB camera to enable MoCap in the wild.
Since a video taken by a single camera contains no depth information, additional assumptions on the scene need to be made. Fortunately, the human body satisfies several constraints: bones lengths limits to specific values, symmetry of opposing body parts, joint angle limits etc. Depending on your interest different machine learning approaches will be applied to learn these constraints from image data.

Related work:
RepNet: Weakly Supervised Training of an Adversarial Reprojection Network for 3D Human Pose Estimation, Bastian Wandt, Bodo Rosenhahn, CVPR 2019

 

Ivan Beschastnikh

Project 1. Privacy-preserving ML on health data

To train multi-party ML models from user-generated data, users must provide and share their training data, which can be expensive or privacy-violating. We are exploring ways to augment state-of-the-art approaches, like federated learning, with better security/privacy.

And, we are developing brand-new distributed ML approaches that do away with centralization. We are collaborating with researchers in the UBC medical school and VGH, and patient groups in the city to come up with technologies that are sensitive to user's privacy constraints and solve real problems. Our work is open source and aims to provide practical alternatives to today's systems that provide minimal privacy guarantees to patients. We are looking for 1-2 students who have a background in ML, databases, networks, or distributed systems. If you're interested in technologies to improve healthcare, then this project is for you! To learn more about our work, visit https://leap-project.github.io/.

 

Kevin Leyton-Brown

Project 1. Deep learning for branch prediction in SAT solvers

Designing efficient algorithms for solving the boolean satisfiability (SAT) problem is crucial for practical applications such as scheduling, planning, and software testing. Machine learning is an important tool in algorithm design for SAT, however SAT practitioners have yet to exploit the representational power of deep learning. We propose to train a neural network to learn to make variable ordering decisions for the widely used CDCL-style SAT solvers.

CDCL SAT solvers search for a solution in a tree-like fashion, where decisions are made to iteratively partition the search space. Existing heuristics for deciding how to partition the search space don't use machine learning to leverage the structure of the internal solver state. We propose to use Monte-Carlo Tree Search (MTCS) reinforcement learning to train a neural network policy to map from internal solver state to partitioning decisions in order to minimize the number of steps required to prove SAT/UNSAT.

Most of the student's work will involve software development and setting up large computational experiments for:

Improving efficiency of Monte-Carlo tree search for generating training data Training neural networks to learn policies for CDCL SAT solver Amortizing cost of queries to neural nets over many consecutive decisions

The student should have basic understanding of machine learning concepts and should be competent in C++ (for SAT solver) and python (for ML). Knowledge of deep learning (pytorch), cluster computing, statistics, and CDCL SAT solvers will be an asset.

Please contact Chris Cameron at cchris13@cs.ubc.ca if interested and to set up a time to talk.

Summer 2020

Alex Summers

Project 1. Prusti - Deductive Verification Tools for Rust

The Prusti project (a collaboration between UBC and ETH Zurich) aims to provide modular, code-level verification tools for Rust, a modern systems programming language. The combination of Rust's advanced ownership type system and user-defined specifications makes it possible to provide scalable and efficient formal verification for a wide variety of program properties, including allowing programmers to express their intentions and check that their code will always live up to these. We are constantly extending Prusti with support for a richer variety of language features: in this project you will contribute to these efforts by designing and/or implementing verification techniques for advanced features such as closures and lifetime constraints. Prior experience with Rust and/or formal reasoning about programs is an advantage, but is not essential; expertise with imperative programming of some kind is needed.

Project 2. Automated Debugging for SMT Solving

SMT solvers have a wide variety of applications across Computer Science, including program analysis and synthesis tools, automated planning and constraint solving, optimisation problems and software verification. Advanced tools such as program verifiers are often built around SMT encodings of their problems. However, designing these encodings to perform reliably and fast is a challenging task. In recent work, we developed the Axiom Profiler tool to serve as a debugging tool for quantifier-rich SMT problems. In this project, you will work to extend this tool to provide new automated techniques for helping a user to zoom in on, diagnose and solve inadequacies in their SMT encodings.

Project 3. Static Program Analysis for Liveness Properties of Message-Passing Programs

Static program analysis techniques typically aim to identify guaranteed program behaviours fully automatically. Program analysers typically tackle *safety* properties, e.g. prescribing that certain program points will only be reached when certain conditions hold. In the context of programs which heavily employ asynchronous messaging (e.g. actor-based programs), *liveness* properties, e.g. stating that servers always eventually respond to requests, are also of central importance. In this project, we will explore the feasibility of a modular static analysis which combines inference of both safety and liveness properties for asynchronous programs.

 

David Poole

Project 1. AIspace2

AIspace (see http://aispace.org) has been developed by USRA students and grad students over a number of years. Recently USRA students created a Python-javascript version (https://aispace2.github.io/AISpace2/install.html) based on open-source AI algorithms in Python (http://aipython.org) created by David Poole and Alan Makworth. The aim is to integrate the code with interactive visualizations that are easy for students to extend and allow the students to modify the AI algorithms. There are three aspects of the project: the first is to make the current AIspace2 code more modifiable and user-friendly. The second is to translate interactive demos (https://artint.info/demos/) to Python. The third is to develop similar tools for the rest of the AIPython code. Skills required: knowledge of the content of CPSC 322, proficiency in Javascript and Python, the ability to write clear and simple code.

 

Dongwook Yoon

Please apply by January 25. For application details please check the following link: https://docs.google.com/document/d/1iRUvK5wGmIZY7ZKeWg-XWW3P1w1qF5rfMQhnbw2IQ7Y/edit.

Project 1. Augmented Reality Interfaces for Asynchronous Collaboration in 3D Environments

This study aims to design and build a collaborative augmented reality (VR/AR) system for annotating a 3D environment with recordings of multimodal interactions (e.g., speech, gesture, gaze), drawing on human-computer interaction approaches. Annotations are basic building blocks of asynchronous collaboration in a shared workspace (e.g., a game director giving feedback to a level designer on a 3D map by commenting on it). However, existing AR annotation interfaces rely primarily on static content (e.g., text, mid-air drawing), which is not as nuanced nor as expressive as in-person communication where people can talk, gaze, and gesture. To enrich and expand communicative capacities of AR annotations, I envisage an AR counterpart of email or Google Docs, where collaborators can record their multimodal performances (e.g., voice, view changes, and hand movements) in a 3D environment and share such rich media-based messages back and forth with other parties. The challenges are as follows: (1) developing an easy-to-use interface for creating and editing the recorded multimodal annotation, (2) designing lightweight interactions for browsing and skimming multimodal recordings, and (3) helping users overcome psychological barriers in recording multimodal inputs (e.g., speech anxiety).

Qualifications
- Successful completion of the introductory computer graphics courses (e.g., CPSC 314)
- (optional) Successful completion of the introductory HCI courses (e.g., CPSC 344 or 544)

Project 2. Computational Text Analysis and Crowd-sourced Annotation of Research Documents for Identifying Gender Bias of Human Subject Sampling

The empirical basis of HCI studies draws on user conditions and needs collected from 'human subjects' (i.e., informants or participants of the study). However, researchers often ignore gender bias in the sample population, in pursuit of expediency and convenience during the sampling process. This underrepresentation can result in theories and guidelines for designing technologies that fail or even harm women and non-binary people. To theorize, validate, and address gender bias in HCI research, We then examine the claims of gender imbalance by establishing a robust evidentiary basis using a computational data-driven meta-analysis of the HCI literature, including ~16K research papers, at-scale. we will integrate computational text analysis into our novel crowd-sourced labeling framework. This study takes three phases as follows: (Phase 1) ‘Data crawling’ of the ~16K HCI publication documents and structuring them in a machine-readable format; (Phase 2) Building a text analysis engine that takes a research paper and automatically identifies paragraphs and sentences containing human subject descriptions (e.g., "Participants" chapters) by using document layout analysis (e.g., X-Y cut) and supervised text classification techniques (e.g., Naive Bayes); and (Phase 3) Building and testing the crowdsourcing framework where the subject’s gender data is extracted from the text snippets from Phase 2.2 and then verified by multiple workers, following Identify-Encode-Verify workflow

Qualifications
- Strong technical skills including OOP, data structures, and algorithms.
- (optional) Successful completion of AI courses (e.g., CPSC 322, 422, or equivalent

Project 3. Natural User Interactions for Video Interfaces

This project aims to build and study novel interaction techniques for browsing and skimming online videos. As we watch videos daily on YouTube, MOOCs, and SNS, video has become a central medium for education, entertainment, and social interactions.  However, the way we interact with videos has remained the same for decades. How can we go beyond a slider-bar and thumbnails? To support dynamic, seamless, and semantic interactions for browsing, searching, and skimming online videos, we will (1) develop novel interaction metaphors, (2) leverage speech and video recognition techniques, and (3) employ natural interaction capacities of modern interactive devices (e.g., touch and gesture of tablets).

Qualifications
- Strong technical skills including OOP, data structures, and algorithms.
- (optional) Successful completion of the introductory HCI courses (e.g., CPSC 344 or 544)

Project 4. Improving Language Education with a Speech and Gesture Commenting System

The goal of this project is to improve foreign language speaking practice with a speech and gesture commenting tool. In face-to-face instruction, speech vanishes into the air without leaving a trace. Due to the transient nature of speech, language instructors don’t have time to provide in-depth feedback on students’ speaking performances, and students miss the opportunity to reflect on their mistakes. To fill this gap, we will build a speech commenting tool, based on an existing rich commenting system called RichReview, through which students can submit speech recordings and instructors can give speech feedback on students’ submissions. This tool has two beneficial features: (1) an animated visual pointer to refer to part of audio content (e.g., “You are using wrong inflection HERE.”), and (2) an efficient browsing feature to replay multiple speech clips quickly and effortlessly. For evaluation, we will pilot the tool in two foreign language courses in UBC.

Qualifications
- Web development skills and experiences (full-stack and node.js preferred)
- (optional) Successful completion of the introductory HCI courses (e.g., CPSC 344 or 544)

 

Helge Rhodin

Project 1. Egocentric motion capture

In recent years, there has been tremendous progress in video-based 6D object pose and human 3D pose estimation, even from head-mounted cameras [Related work]. They can now both be done in real time but not yet to the level of accuracy that would allow the capture how people interact with other people and with objects, which is a crucial component of modeling the world in which we live. For example, when someone grasps an object or shakes someone else’s hand, the position of their fingers with respect to what they are interacting with must be precisely recovered if the resulting models are to be used in see-through AR devices, such as the Hololens or consumer-level video see-through versions.
Key to this project is the accurate modeling of contact points and the resulting physical forces between interacting hands and feet with the surrounding. The hardware setup will be a mobile head-mounted camera, building upon our egocentric motion capture work (EgoCap) [Related work]. The goal of this project is to use inertial measurement units (IMUs) and deep learning to sense ground contact and relative positions.

Related work:
EgoCap: Egocentric Marker-less Motion Capture with Two Fisheye Cameras. Helge Rhodin, Christian Richardt, Dan Casas, Eldar Insafutdinov, Mohammad Shafiei, Hans-Peter Seidel, Bernt Schiele, and Christian Theobalt. SIGGRAPH Asia 2016

Project 2. Gravity for scale estimation in multi-view reconstruction

This project aims at reconstructing objects and camera geometry by exploiting the Newton's equations of motion and gravity. Estimating metric scale from image or video recordings is a fundamental problem in computer vision and important for determining distances in forensics, autonomous driving, person re-identification, and structure-from-motion (SfM). In general, object size and distance cancel in perspective projection---which makes the problem ill-posed.
The main idea is to use the omnipresent gravity on earth as a reference 'object'. Newton's second equation of motion dictates that the trajectory of an object is a parabola, a function of time, its initial speed and position, with the curvature determined by the acceleration induced by constant external forces. This project build upon our earlier work on estimating a person’s height by relating acceleration in the image and to gravity on earth [Related work], as sketched in the inset. By contrast, the aim of this project is to use similar principles for multi-view reconstruction, for structure from motion and automatic camera calibration.

Related work:
Gravity as a Reference for Estimating a Person's Height from Video. Didier Bieler, Semih Günel, Pascal Fua, and Helge Rhodin. ICCV 2019

Project 3. Learning anthropometric constraints for monocular human motion capture

In recent years image-based human motion capture (MoCap) has progressed immensely with varying applications in e.g. movie production, sports analytics, virtual reality systems, games, human computer interaction, and medical examinations. Nowadays marketable software in these fields requires sophisticated motion capture studios and expensive measurement devices which strongly limits its applicability. This project aims to achieve human MoCap using only a single RGB camera to enable MoCap in the wild.
Since a video taken by a single camera contains no depth information, additional assumptions on the scene need to be made. Fortunately, the human body satisfies several constraints: bones lengths limits to specific values, symmetry of opposing body parts, joint angle limits etc. Depending on your interest different machine learning approaches will be applied to learn these constraints from image data.

Related work:
RepNet: Weakly Supervised Training of an Adversarial Reprojection Network for 3D Human Pose Estimation, Bastian Wandt, Bodo Rosenhahn, CVPR 2019

 

Ivan Beschastnikh

Project 1. Privacy-preserving ML on health data

To train multi-party ML models from user-generated data, users must provide and share their training data, which can be expensive or privacy-violating. We are exploring ways to augment state-of-the-art approaches, like federated learning, with better security/privacy. And, we are developing brand-new distributed ML approaches that do away with centralization. We are collaborating with researchers in the UBC medical school and VGH, and patient groups in the city to come up with technologies that are sensitive to user's privacy constraints and solve real problems. Our work is open source and aims to provide practical alternatives to today's systems that provide minimal privacy guarantees to patients. We are looking for 1-3 students who have a background in ML, databases, networks, or distributed systems. If you're interested in technologies to improve healthcare, then this project is for you!

Project 2. Better resource scheduling in the cloud

We rely on some cloud for most of our daily activities on and off the web. A challenge for cloud providers is to efficiently utilize their data-centers that house hundreds of thousands of servers. A common technique to multiplex server resources across multiple users is to isolate each user's compute requirement as a Virtual Machine (VM). Thus, the cloud resource allocation challenge is equivalent to placing VMs on servers based on some objective, such as maximizing a datacenter's utilization. In this project we are developing new algorithms and systems to improve resource scheduling in the cloud. Some algorithms rely on training ML models to predict the lifetime of a user's VM, others rely on heuristics that pack related VMs closer to each other. Our work is open source and we are working with cloud providers to deploy our algorithms into production data centers. For this project we are looking for 1-2 students who have a background in algorithms, ML, and networks or distributed systems. A longer description of the project is posted here. If you're interested in algorithms and cloud computing, then this project is for you! 

 

Ian Mitchell

All projects below list a small number of required skills and a larger number of "useful" skills.  Do not be discouraged by the latter -- applicants are not required to have any of those skills, and most applicants will have no more than a few.

For all positions applicants must be prepared to work independently, to express themselves clearly in discussions, and to give at least two brief presentations to the research group.

If you are interested in applying for one or more of these positions, please email ian.mitchell@ubc.ca with your resume/CV and a transcript.  The subject should be "USRA application".  Please state in your email which project(s) you are interested in (numerical software, wheelchair and/or racer).

Project 1. Numerical software for analyzing cyber-physical systems

Cyber-physical systems are those which involve interaction between computers and the external world, and include many safety critical systems such as aircraft, cars, and robots.  Analysis of these systems typically uses differential equation models for the physical component of the system, because its state evolves in continuous time and space.  Reachability algorithms can be used to verify -- or even synthesize controllers to ensure -- the correct behavior of dynamic systems, and a variety of such algorithms have been designed for differential equation models.  The goal of this project is to demonstrate a new example on, improve the user interface of, validate the implementation of, parallelize and/or add features to one of several software packages used for approximating sets of solutions in order to demonstrate the correctness of robotic or cyber-physical systems.  The Toolbox of Level Set Methods [http://www.cs.ubc.ca/~mitchell/ToolboxLS] is a locally developed example, but others include JuliaReach [https://github.com/JuliaReach], CORA [http://www6.in.tum.de/Main/SoftwareCORA] and SpaceEx [http://spaceex.imag.fr/].  Applicants should be comfortable with numerical ODE solvers (for example, CPSC 303 or Math 405) and a numerical computing language (such as Matlab, SciPy, or Julia).  Familiarity with computational optimization (such as CPSC 406), parallel programming (such as CPSC 418), machine learning (such as CPSC 330 or 340), or numerical partial differential equations (such as Math 405) would be useful for some but not all potential subprojects.

Project 2. Collaborative control scheme design, simulation and testing for a smart wheelchair

As part of the AGE-WELL Network Center of Excellence [http://www.agewell-nce.ca] I have a project investigating techniques which would allow elderly individuals with mild cognitive and/or sensory impairments to better use powered wheelchairs.  While it is relatively easy to implement a system in which either the user or the robotic planner chooses the motion of the wheelchair, it is much more challenging to blend these two inputs in real-time and in a manner which is both safe and non-threatening to a cognitively impaired user.  As part of this process, the team runs user studies with the target population and their therapists in long term care centers.  Potential goals for this summer's project include ongoing prototype development and evaluation of collaboration and training interfaces and control policies, development and evaluation of learning methods for predicting behavior of the chair and/or user, data collection and analysis from real-world or virtual trials, or setting up a virtual reality workstation for trials of collaboration control policies.  Applicants should be comfortable with C++, Matlab and/or Python, and will be expected to learn and use ROS (robot operating system) to program the wheelchair(s).  Familiarity with human-computer interaction (such as CPSC 344), computational optimization (such as CPSC 406), machine learning (such as CPSC 330 or 340), computer vision (such as CPSC 425) or electronics would be useful for some but not all potential subprojects.

Project 3. Software development, motion modeling, sensor integration, collaborative control scheme design, and testing for a highly dynamic ground robot

The wheelchair project focuses on a collaborative control problem where the vehicle is large but slow moving, the environment is unconstrained, the user is untrained, and the interface options are limited.  At the other end of the spectrum, autonomous racing vehicles are small and fast, the environment is more constrained, users can be highly trained, and it is possible to design richer interfaces. Potential platforms include the NVIDIA Jetracer [https://github.com/NVIDIA-AI-IOT/jetracer] or F1tenth [http://f1tenth.org/].  Goals for this project include characterizing the racer(s) physics, integrating sensors, designing a collaborative control scheme, designing an interface, and testing the results.  Applicants should be comfortable with C++, and will be expected to learn and use ROS (robot operating system) to control the vehicles.  Familiarity with machine learning (such as CPSC 330 or 340), computer vision (such as CPSC 425), human-computer interaction (such as CPSC 344), computational optimization (such as CPSC 406), parallel programming (such as CPSC 418), system identification, electronics, mechatronics or autonomous vehicles would be useful for some but not all potential subprojects.

 

Khanh Dao Duc

Project 1. Building an interface to classify and cluster ribosome components from the Protein Data Bank (PDB)

My group is looking for a CS student to use bioinformatic tools and implement computational methods for analyzing molecular structures found by cryo-EM or X-ray crystallography.  In the context of my recent research, there is a need for studying a family of these structures, called ribosomes.  Ribosomes are the molecular machines that mediate protein translation, one of the most fundamental process  underlying  life. Since the ribosome is  made of many different  proteins, a key question is to understand differences in composition for different species,  and have the tools to automate such comparison. For the past few years, many new ribosomes structures have been discovered and publicly shared through the Protein Databank. The goal will be to develop the tools and an interface that allows the user to compare and visualize all these structures and the proteins (~80 for each structure) that constitute a ribosome, to identify homologous proteins, clusters of proteins close in space, label them according to their position, and implement general methods for geometric comparison.

I am currently working on writing an invited review on the heterogeneity of cryo-EM structures, in collaboration with Dr Frederic Poitevin (Stanford), to be submitted in spring, so some results for this project will be added in the review (with the student added as co-author). We also expect this project to lead to a bioinformatic tool and subsequent paper in bioinformatics, describing how it can be used to quantitatively study ribosome structures.

Reference: Dao Duc et al., 2019, Nucleic Acids Research, https://academic.oup.com/nar/article/47/8/4198/5364857

 

Kevin Leyton-Brown

Project 1. Improving efficiency and student satisfaction in peer grading systems

Peer grading has the potential to improve educational outcomes in three main ways: (i) it makes educational systems more scalable by offloading some grading work to students, (ii) it provides students with faster and more detailed feedback, and (iii) it helps students to learn better through thinking critically about the work of others. Mechanical TA2 (MTA2) is a web-based peer grading application that facilitates peer grading. The newest version is just now receiving its first uses but is still a work in progress. The initial use of MTA2 provided evidence that while students benefited from doing the peer reviews, they doubted the quality of the grades that they got through their peers. The focus of this project is to study the effectiveness of the current MTA2's design and try to improve it as much as possible.  

Student’s role in the project: 

1. Investigating the data gathered through MTA2’s initial use and searching for the sources of inefficiencies that caused students dissatisfaction in the course (e.g., the way that peer grading are aggregated, common trends in the way students grade or common patterns in the grades they received).   

2. Coming up with solutions to improve the inefficiencies in the systems design (e.g., suggesting a better grade aggregation method). 

3. Implementing new features in MTA2 based on the obtained solutions to improve the system’s efficiency. 

Skilled required for the project: Data analysis, programming, and the ability to work independently.

 

Margo Seltzer

Project 1.

Reproducibility is a crucial tenet of research. Scientists can freely share their code and data to help increase the repeatability of their experiments. However, even with scripts used by the original authors, executing them is not guaranteed the same results. Provenance, a history of the execution of a script, can assist in increasing the reproducibility of these analyses. Previous work, containR, used provenance with the R language to bundle scripts and data into containers, improving their repeatability. This work will build on containR for Python scripts. Using provenance collected at the source code level, the student will assess analyses and build a tool to improve the reproducibility of new and existing experiments.

Project 2.

In CPSC 313, we use the y86 language to teach about machine architecture.

It would be convenient to have a compiler that generates y86 code. In theory, developing a backend for LLVM should be straight forward. In practice, doing so is not entirely trivial and will requires some creativity.  If you would like an opportunity to build a production compiler backend, this project is for you!

 

Reid Holmes

Project 1. Evaluating Quality Impact of Static Analysis Tools

Software systems are complex entities built by teams of engineers. Teams frequently enforce rules that require source code be written according to a set of pre-defined rules to increase it's consistency between team members. Automated tools such as lint and checkstyle are commonly used to statically check these rules are followed and usually disallow changes being added to version control unless they are followed. While the primary goal of these rules is to improve the overall understandability of the system, often-stated tangential goals are to improve the quality and evolvability of the system. While the consistency enforced by style conventions clearly make it easier to understand a system that has been created by a large team, the evidence for quality and evolutionary benefits has not been clearly established.

This project will investigate whether the introduction of common linting rules aimed at improving quality (such as maximum file or method length) have any impact on the overall evolvability or quality of a system. The project will examine both OSS projects as well as locally-available educational resources for which we have a rich collection of lint-related projects.

 

Andy Roth

Project 1. Improving computational workflows for the analysis of spatial transcriptomic data

Emerging technologies are allowing biologists to generate increasingly large and complex datasets. One exciting new area of technology are spatial omics methods which leverage advanced micro-fluidics and high resolution microscopy to measure the abundance of RNA and proteins in cells in 2D. The Roth lab is working with other scientists at BC Cancer to develop computational methods to analyze this data. This project will focus on the analysis data generated by a protocol called “Multiplexed error-robust fluorescence in situ hybridization” (MERFISH).

MERFISH analysis generates a large number of high resolution microscopy images, which can go through a sophisticated computational analysis pipeline. Key steps in this pipeline include alignment and stitching of images, identification of spots representing RNA, segmentation of cell boundaries, and “decoding” the RNA barcodes. The Roth lab has currently implemented a Python based pipeline based on the original MERFISH paper. The successful applicant will be responsible for maintaining this pipeline and implementing new features under the supervision of Dr. Roth and his graduate students. Knowledge of best practices in software engineering such as unit testing, version control and continuous integration are required. Previous experience with image analysis, machine learning and familiarity with Python would all be assets.

Project 2. Non-parametric Bayesian models for cancer stratification

It is increasingly apparent that cancer is a collection of related diseases, caused by cells with differing mutational and gene expression profiles. Understanding these differences, and stratifying cancers into subtypes has important implications for the treatment of patients. Current approaches which apply high throughput genomics data to stratify subtypes have been restricted to analysing cancers from a single anatomical region. However, there is now a large quantity of data from multiple types of cancer which could be analysed jointly. A major impediment to this task, is that the cancer samples tend to cluster together primarily by their cell or anatomical region of origin. Thus a joint cluster analysis is not significantly more informative than considering each type of cancer separately.

This project will explore the use of feature allocation models instead of clustering models to perform molecular stratification of cancers across multiple types. This should allow for latent features that explain the dominant signal from the tissue of origin, with additional features explaining important alterations causing malignancy. By allowing these features to be shared across cancers from multiple types, we expect to simultaneously gain statistical power as well as identify molecular subtypes which span multiple cancer types.

The successful applicant will work with Dr. Roth and his graduate students developing a generative model based on the non-parametric Bayesian Indian Buffet Process (IBP) for analysing gene expression data from multiple cancer types. The student will help implement inference procedures for the model using Markov Chain Monte Carlo and potentially variational methods. In addition to developing experience in statistical modelling and computation, the student will also gain a basic knowledge of high throughput genetic sequencing data and its impact in oncology and clinical cancer genomics. The student will apply the model to real world data from the International Cancer Genome Consortium, which has generated gene expression data for ~9,000 samples from 16 types of cancer. A strong mathematical background with at least one course in probability is required. Students who have taken courses in computational statistics and machine learning would be good candidates. Familiarity with Python and numerical libraries such as numpy, scipy, numba and pandas would an asset. A basic knowledge of biology is also required i.e. what is RNA?

Project 3. Single cell multi-omics data

Single cell sequencing technologies are revolutionising cancer research. Biologists are now able to measure different features such as DNA, RNA and methylation of 100s-1000s of cells. However, we can typically only make one type of measurement per cell as the measurement process is destructive. As a result it is challenging to relate measurements of different features. Below are two potential projects related to this field.

Project 3a: Analysis of multi-omics data

The Roth lab is working with collaborators at BC Cancer who have generated extensive single cell datasets. This sub-project will focus on the analysis of the data. As such it requires a strong biological background and would be ideal for a student interested in pursuing graduate studies in Bioinformatics. The successful applicant will work with Dr. Roth and his graduate students to analyse single cell datasets and integrate the different measurements to develop biological hypotheses. A background in statistics or machine learning is required. In particular familiarity with dimensionality reduction techniques such as PCA and also regression techniques is required. The applicant must also be familiar with data science workflows in either R or Python. Previous bioinformatics experience is desirable.

Project 3b: Methods for integrating multi-omics data

The current standard for integrating multi-omics data is driven by independent analysis of each data type and subsequent manual integration by domain experts. This approach is laborious due to the scale of the datasets, and lacks statistical power as each type of data is treated independently. This project will focus on developing statistical and machine learning methods for automating the integration of single cell multi-omics data. A strong mathematical background with at least one course in probability is required. Students who have taken courses in computational statistics and machine learning would be good candidates. Familiarity with Python and numerical libraries such as numpy, scipy, numba and pandas would be an asset. A basic knowledge of biology is also required i.e. what is RNA?

Summer 2019

Giuseppe Carenini

Project 1. Interpreting and Comparing NLP models.

The student will be involved in a project at the intersection of natural language processing (NLP) and information visualization (InfoVis). In my research group, we are working on several NLP frameworks for tasks like discourse parsing, text summarization and topic modelling. While developing such systems, it is often useful to compare the output of different methods to assess which one is performing better and why. The student will contribute to the design, implementation and testing of one or more components of an intelligent interface to support the interpretation and comparison of the output of our NLP models.

Project 2. Design and Evaluate Models for Discourse Parsing

The student will be assigned to a research project within the areas of Natural Language Processing (NLP) and Deep Learning (DL). He/She will be mainly working on the open research problem of large-scale discourse parsing, extending recent research in my group. In the NLP group, we are working on several diverse NLP tasks such as text summarization, topic modelling as well as the fundamental task of discourse parsing, which has shown to be beneficial for many downstream tasks such as machine translation and sentiment analysis. To design, implement and evaluate models for discourse parsing, the student will use his/her working knowledge of probabilistic and connectionist machine learning methodologies to help realize systems based on deep neural networks and probabilistic frameworks. The student will be required to work as part of the research team and justify design decisions, test his/her implementations and critically reflect on embedding literature.

Cristina Conati

Project 1. Delivering adaptive interventions for personalization of intelligent user interfaces based on user's eye-tracking patterns

The overall goal of this project is to devise intelligent user interfaces that can track their users’ gaze and use it to predict user states (e.g., user attention level, confusion, engagement, cognitive abilities) relevant to automatically personalize the interaction. We have developed in our research lab a platform that can track a user's gaze in real-time, while the user is processing the interface, and trigger personalized interventions based on the user's gaze behaviors.

We are looking for an undergraduate research assistant to implement personalized interventions in visualization-based user interfaces, using our platform. Specifically, the student will implement graphical interventions that can be delivered to users during specific interaction tasks, based on their gaze behaviors. The student may also assist with  implementing functionalities for processing user gaze information, and with training machine learning algorithm to predict specific user states.

The student will work closely with PhD student Dereck Toker and Postdoctoral Fellow Sebastien Lalle.

Qualifications:

  • 3rd or 4th year undergraduate student in computer science
  • knowledgeable in Python and JavaScript
  • can document and maintain code on Github

Charlotte F. Fischer

Project 1. Atomic Structure Software

In quantum theory, every observable can be computed, given the wave function which is the solution of a partial differential equation  of high dimensionality. For Uranium with 92 electrons the number of space variables is 276. Variational methods are used for determining approximate solutions. Software for atomic structure calculations based on non-relativistic theory (ATSP), was  started at UBC  in the 1960’s and fully relativistic Dirac theory (GRASP) in the 1980’s. The programming language for these codes  is now FORTRAN77 and the only data structures that are used are vectors, matrices (arrays), and lists. The codes are published and used worldwide. But “modern” FORTRAN has many new features that  makes possible user defined data types and  totally new memory management procedures for more object oriented software. For heavy elements  that make excessive demands on both  memory and computation, parallel  versions are essential. This project will explore the development  of user defined data structures for atomic physics leading to more readable and more efficient research software. Applicants  should be sufficiently familiar with numerical computing and programming languages to be able to learn FORTRAN  quickly and be able to use the Git version control system. 

Ian Mitchell

Project 1. Exploring Mutation Testing as a Method of Numerical Software Verification

A key challenge when testing numerical software is that exact oracles (against which to test) do not exist: Even if one can construct a test case free of approximation, discretization and truncation error, floating point error is present and typically difficult to quantify for all but the most simple of calculations.  Common workarounds typically involve thresholds for "close enough", but choosing the threshold is a somewhat arbitrary process.  The goal of this project is to explore whether ideas from mutation testing might yield more rigorous criteria with which to build confidence in a code.  In the normal application of mutation testing, "target code" which passes all existing tests is subject to random source modification; if the resulting "mutant code" executes and is not caught by at least one test case then the test coverage is incomplete.  This project will explore whether an alternative measure of the mutants might usefully be deployed to catch real bugs in publicly released scientific computing codes.  Applicants should be familiar with numerical computing (for example, CPSC 302, 303, 406 or Math 307, 405) and the use of the git version control system.  Familiarity with one or more open-source scientific computing libraries and/or software testing methods is useful but not required.

Project 2. Numerical Software Development for Differential Equations

Cyber-physical systems are those which involve interaction between computers and the external world, and include many safety critical systems such as aircraft, cars, and robots.  Analysis of these systems typically uses differential equation models for the physical component of the system, because its state evolves in continuous time and space.  Reachability algorithms can be used to verify -- or even synthesize controllers to ensure -- the correct behavior of dynamic systems, and a variety of such algorithms have been designed for differential equation models.  The goal of this project is to demonstrate a new example on, improve the user interface of, validate the implementation of, parallelize and/or add features to one of several software packages used for approximating sets of solutions in order to demonstrate the correctness of robotic or cyber-physical systems.  The Toolbox of Level Set Methods [http://www.cs.ubc.ca/~mitchell/ToolboxLS] is a locally developed example, but others include SpaceEx [http://spaceex.imag.fr/] or CORA [http://www6.in.tum.de/Main/SoftwareCORA].  Applicants should be familiar with numerical ODE solvers (for example, CPSC 303 or Math 405) and Matlab (or SciPy or Julia).  Familiarity with computational optimization (such as CPSC 406) and/or parallel programming (such as CPSC 418) would be useful for some but not all potential subprojects.

Project 3. Collaborative control scheme design, simulation and testing for a smart wheelchair

As part of the AGE-WELL Network Center of Excellence [http://www.agewell-nce.ca] I have a project investigating techniques which would allow elderly individuals with mild cognitive and/or sensory impairments to better use powered wheelchairs.  While it is relatively easy to implement a system in which either the user or the robotic planner chooses the motion of the wheelchair, it is much more challenging to blend these two inputs in real-time and in a manner which is both safe and non-threatening to a cognitively impaired user.  As part of this process, the team runs user studies with the target population and their therapists in long term care centers.  Potential goals for this summer's project include ongoing prototype development and evaluation of collaboration and training interfaces and control policies, development and evaluation of learning methods for predicting behavior of the chair and/or user, data collection and analysis from real-world or virtual trials, or setting up a virtual reality workstation for trials of collaboration control policies.  Applicants should be familiar with C++, Matlab and/or Python, and will be expected to learn and use ROS (robot operating system) to program the wheelchair(s).

Project 4. Design of wheelchair control system

As part of the smart wheelchair project we have developed a prototype embedded system to interface with the wheelchair and allow remote and computer moderated control.  This summer project is focused on redesigning this prototype to reduce complexity and replace commercial products that are no longer available.  The current system uses an Arduino, a small custom analog interface board, a laptop and the old Playstation Move's navigation controller.  The goal of this project is to identify a wireless one-handed controller to replace the Move, identify a microcontroller and/or embedded microprocessor which can replace the current Arduino and accomplish the basic tasks currently performed on the laptop, and possibly replace the custom analog board, as well as packaging the solution robustly enough to survive extended user trials.  Applicants should have experience with digital and/or analog electronics and embedded platforms (such as Arduino, BeagleBoard, RaspberryPi, ...), and will be expected to learn and use ROS (robot operating system) on the software side.

David Poole

Project 1. AIspace2 

AIspace (see http://aispace.org) has been developed by USRA students and grad students over a number of years. Recently USRA students created a Python-javascript version (https://aispace2.github.io/AISpace2/install.html) based on open-source AI algorithms in Python (https://artint.info/AIPython/) created by David Poole and Alan Mackworth. The aim is to integrate the code with interactive visualizations that are easy for students to extend and allow the students to modify the AI algorithms. There are three aspects of the project: the first is to make the current AIspace2 code more modifiable and user-friendly. The second is to translate interactive demos (https://artint.info/demos/) to Python. The third is to develop similar tools for the rest of the AIPython code. Skills required: knowledge of the content of CPSC 322, proficiency in Javascript and Python, the ability to write clear and simple code.

Margo Seltzer

Project 1. A Parallel Implementation of Certifiably Optimal Decision Trees

Rule lists are a kind of interpretable machine learning model. They can be viewed as a sequence of cascading if statements. For example, there is a widely used data set used to predict if an individual is likely to commit a crime within the next two years. The following model is a model to make that prediction: if (age = 18-20) and (gender = male) then predict yes, else if (age = 21-23) and (priors = 2-3) then predict yes, else if (priors > 3) then predict yes, else predict no. Not only is this a real predictive model, we have proven that it is the best model that can be constructed, given a regularized loss function. In prior work we presented an algorithm and implementation to produce such optimal rule lists.

A rule list is a a specific kind of a more general model called a decision tree. In more recent work, we have developed an algorithm to produce similarly optimal decision trees. However, as the search space of decision trees is significantly larger, this is a much more challenging problem. Our goal for this research project is to develop a parallel implementation of an optimal decision tree algorithm that will allow us to find optimal models for an increasingly large number of features.

Dongwook Yoon

Project 1. Mixed-Reality Interfaces for Asynchronous Collaboration in 3D Environments

This study aims to build a virtual/augmented reality (VR/AR) system for annotating a 3D environment with recordings of multimodal interactions (e.g., speech, bodily gesture, gaze), drawing on human-computer interaction approaches. Annotations are basic building blocks of asynchronous collaboration in a shared workspace (e.g., a game director giving feedback to a level designer on a 3D map by commenting on it). However, existing AR annotation interfaces rely primarily on static content (e.g., text, mid-air drawing), which is not as nuanced nor as expressive as in-person communication where people can talk, gaze, and gesture. To enrich and expand communicative capacities of AR annotations, I envisage an AR counterpart of email or Google Docs, where collaborators can record their multimodal performances (e.g., voice, view changes, and hand movements) in a 3D environment and share such rich media-based messages back and forth with other parties. The challenges are as follows: (1) developing an easy-to-use interface for creating and editing the recorded multimodal annotation, (2) designing lightweight interactions for browsing and skimming multimodal recordings, and (3) helping users overcome psychological barriers in recording multimodal inputs (e.g., speech anxiety).

Qualifications

  • Successful completion of the introductory computer graphics courses (e.g., CPSC 314)
  • (optional) Successful completion of the introductory HCI courses (e.g., CPSC 344 or 544)

Project 2. Natural User Interactions for Video Interfaces

This project aim to build and study novel interface techniques for interacting with videos. As we watch videos daily on MOOCs, YouTube, and SNS, video has become a central medium for education, entertainment, and social interactions.  However, the way we interact with videos has remained the same for decades. How can we go beyond a slider-bar and thumbnails? To support dynamic, semantic, and visual interactions for video browsing, searching, and skimming, we will (1) develop novel interaction metaphors, (2) leverage speech and video recognition techniques, and (3) employ natural interaction capacities of modern interactive devices (e.g., touch and gesture of tablets).

Qualifications

  • Strong technical skills including OOP, data structures, and algorithms.
  • (optional) Successful completion of the introductory HCI courses (e.g., CPSC 344 or 544)

Summer 2018 

Ivan Beschastnikh

Project 1: faster and stronger data center systems

You are curious about where your gmail and facebook messages are stored. You have taken core systems courses. And, you don't mind spending the summer learning about how data centers work and how to make them more reliable and how to make them go faster. You like performance and you are (appropriately) angry at Intel and co. about Spectre and Meltdown.

Project 2: reliable and correct distributed systems

You have come to realize that most software uses the network and that means it is distributed, relying on parts unknown, and always communicating. You have a hunch that distribution means complexity and complexity means bugs. You don't like bugs. You want to understand the pain points and help improve the life of future developers by empowering them with tools and methodologies. You like the sound of software engineering for software engineers.

Project 3: distributed and private machine learning

Cristina Conati and Dr. Lalle

Project: Predicting relevant user states via eye-tracking in intelligent user interfaces

The overall goal of this project is to devise intelligent user interfaces that can track their users’ gaze and use it to infer user states ( (e.g., user attention level, confusion, engagement, cognitive abilities) relevant to automatically personalize the interaction.

Kevin Leyton-Brown

Chris Cameron at cchris13@cs.ubc.ca 

Project: Advances in Empirical Algorithms

Designing efficient algorithms for solving NP-complete problems is crucial for practical applications such as scheduling, planning, and spectrum auctions. Machine learning is becoming an important tool in algorithm design, automating design decisions that previously required extensive manual work by domain experts. The student will work on advancing automating algorithm design by contributing to one or both of two projects:

  1. Developing more “robust” models for algorithm selection: Algorithm selection is the problem of learning to select among a set of complementary heuristic algorithms based on historical runtime data. This project is inspired by recent observations that machine learning models for algorithm selection tend to capture “artificial” relationships in data. The models often perform very well on standard benchmarks but appear to exploit sampling bias and learn the benchmark generation process rather than the underlying structure determining algorithm performance. By investigating ideas from machine learning and game theory, the student will work on developing more “robust” and generalizable models. This may involve optimizing against adversarial changes to the data, altering the data generation process for benchmarks, and/or looking for causal relationships in the data.
  2. Building a new algorithm configuration system: Algorithm configuration is the problem of learning high performance algorithm parameters over a distribution of problem instances. This project will build on a recent theoretical model for algorithm configuration that has provable optimality guarantees and is potentially much more efficient in practice than state of the art techniques. The student will be involved in thinking about practical considerations for software implementation of this theoretical work and run large-scale experiments to empirically investigate these ideas on real data.

What experience is necessary?

The student should have basic understanding of machine learning concepts and should be competent in java and python. Knowledge of cluster computing, statistics, and game theory will be an asset.

Alan Mackworth and David Poole

Project: AIspace2 with Alan Mackworth and David Poole

AIspace (see http://aispace.org) has been developed by USRA students and grad students over a number of years. Last year's USRA student created a Python-javascript version (https://aispace2.github.io/AISpace2/install.html) based on open-source AI algorithms in Python (http://aipython.org) that we created. The aim is to integrate the code with interactive visualizations that are easy for students to extend and allow the students to modify the AI algorithms. There are two aspects of the project: the first is to make the current AIspace2 code more modifiable and user-friendly.  The second is to develop similar tools for the rest of the AIPython code. Skills required: proficiency in Javascript and Python, the ability to write clear and simple code.

Karon MacLean and Paul Bucci

spin-info@cs.ubc.ca

Project 1: Haptic Database

Many force-feedback devices are proposed in the haptic (i.e., related to touch) literature. We are interested in collecting a list of these devices, extracting their properties, and establishing the links between these devices (e.g., ancestry links). This project has many aspects and can be broken down into a narrower project depending a research student's interests. For example, we need to analyze a large corpus of 25 years of haptic literature, some of which are scanned documents, which could be good for someone interested in either Natural Language Processing or literature review.

Project 2: Haptic Pen

A "haptic pen" is a device that acts like a combination of a stylus and a force-feedback device. It's a pen that you can push around—but it pushes back. We need someone to extend an already-existing haptic I/O library/API to control this pen such that it can simulate interaction forces with a virtual environment. Some knowledge of mechatronics, machine learning, and virtual haptic environments useful but certainly not necessary. C++ and Python needed.

Project 3: Low-DOF robot construction

The CuddleBits are low-DOF furry robots designed for emotional interaction. Students will build robots and/or design emotionally-evocative behaviours. Especially needed are people who are skilled in the visual and performance arts, i.e., any of 3D design, graphic design, sculpture, clothing design, sewing, puppeteering, theatrical performance, voice acting, etc. Traditional mechatronics and programming skills not needed but are welcomed. 

Project 4: Interactive biometric emotion modelling

Using biometric sensing technologies such as electroencephalography (EEG), heart rate monitoring, skin conductance, etc., we can develop models of human emotion states. We are currently looking for students who are interested in learning how to (a) use an EEG system and related biometrics to gather data; (b) run human subjects in emotional situations (e.g., playing a video game, interacting with robots); (c) building machine learning models that relate emotion states to biometric data. Expertise in either machine learning or human subjects studies required (i.e., CPSC 340 or equivalent OR CPSC 344/444 or equivalent, but both not necessary).

Ian Mitchell

Project 1: Numerical Software Development for Differential Equations

Cyber-physical systems are those which involve interaction between computers and the external world, and include many safety critical systems such as aircraft, cars, and robots.  Analysis of these systems typically requires differential equation models for the physical component of the system, because its state evolves in continuous time and space.  Reachability algorithms can be used to verify -- or even synthesize controllers to ensure -- the correct behavior of dynamic systems, and a variety of such algorithms have been designed for differential equation models.  The goal of this project is to demonstrate on a new example, improve the user interface of, validate the implementation of, parallelize and/or add features to one of several software packages used for approximating sets of solutions in order to demonstrate the correctness of robotic or cyber-physical systems.  The Toolbox of Level Set Methods [/~mitchell/ToolboxLS/] is a locally developed example, but others include SpaceEx [http://spaceex.imag.fr/] or CORA [https://tumcps.github.io/CORA/].  Applicants should be familiar with numerical ODE solvers (for example, CPSC 303 or Math 405) and Matlab (or SciPy).  Familiarity with computational optimization (such as CPSC 406) and/or parallel programming (such as CPSC 418) would be useful for some but not all potential subprojects.

Project 2: Collaborative control scheme design, simulation and testing for a smart wheelchair

As part of the AGE-WELL Network Center of Excellence [http://www.agewell-nce.ca] I have a project investigating techniques which would allow elderly individuals with mild cognitive and/or sensory impairments to better use powered wheelchairs.  While it is relatively easy to implement a system in which either the user or the robotics chooses the motion of the wheelchair, it is much more challenging to blend these two inputs in real-time and in a manner which is both safe and non-threatening to a cognitively impaired user.  As part of this process, the team runs user studies with the target population and their therapists in long term care centers.  Potential goals for this summer's project include ongoing prototype development and evaluation of collaboration and training interfaces and control policies, development and evaluation of learning methods for predicting behavior of the chair and/or user, data collection and analysis from real-world or virtual trials, or setting up a virtual reality workstation for trials of collaboration control policies.  Applicants should be familiar with C++, Matlab and/or Python, and will be expected to learn and use ROS (robot operating system) to program the wheelchair(s).

Project 3: Design of wheelchair control system

As part of the smart wheelchair project we have developed a prototype embedded system to interface with the wheelchair and allow remote and computer moderated control.  This summer project is focused on redesigning this prototype to reduce complexity and replace commercial products that are no longer available.  The current system uses an Arduino, a small custom analog interface board, a laptop and the old Playstation Move's navigation controller.  The goal of this project is to identify a wireless one-handed controller to replace the Move, identify a microcontroller and/or embedded microprocessor which can replace the current Arduino and accomplish the basic tasks currently performed on the laptop, and possibly replace the custom analog board, as well as packaging the solution robustly enough to survive extended user trials.  Applicants should have experience with digital and/or analog electronics and embedded platforms (such as Arduino, BeagleBoard, RaspberryPi, ...), and will be expected to learn and use ROS (robot operating system) on the software side.

Dongwook Yoon

Project 1: Mixed-Reality Interfaces for Asynchronous Collaboration in 3D Environments

This study aims to build a virtual/augmented reality (VR/AR) system for annotating a 3D environment with recordings of multimodal interactions (e.g., speech, bodily gesture, gaze), drawing on human-computer interaction approaches. Annotations are basic building blocks of asynchronous collaboration in a shared workspace (e.g., a game director giving feedback to a level designer on a 3D map by commenting on it). However, existing AR annotation interfaces rely primarily on static content (e.g., text, mid-air drawing), which is not as nuanced nor as expressive as in-person communication where people can talk, gaze, and gesture. To enrich and expand communicative capacities of AR annotations, I envisage an AR counterpart of email or Google Docs, where collaborators can record their multimodal performances (e.g., voice, view changes, and hand movements) in a 3D environment and share such rich media-based messages back and forth with other parties. The challenges are as follows: (1) developing an easy-to-use interface for creating and editing the recorded multimodal annotation, (2) designing lightweight interactions for browsing and skimming multimodal recordings, and (3) helping users overcome psychological barriers in recording multimodal inputs (e.g., speech anxiety).

Qualifications

  • Successful completion of the introductory computer graphics courses (e.g., CPSC 314)
  • (optional) Successful completion of the introductory HCI courses (e.g., CPSC 344 or 544)

Project 2: Natural User Interactions for Video Interfaces

This project aim to build and study novel interface techniques for interacting with videos. As we watch videos daily on MOOCs, YouTube, and SNS, video has become a central medium for education, entertainment, and social interactions.  However, the way we interact with videos has remained the same for decades. How can we go beyond a slider-bar and thumbnails? To support dynamic, semantic, and visual interactions for video browsing, searching, and skimming, we will (1) develop novel interaction metaphors, (2) leverage speech and video recognition techniques, and (3) employ natural interaction capacities of modern interactive devices (e.g., touch and gesture of tablets).

Qualifications

  • Strong technical skills including OOP, data structures, and algorithms
  • (optional) Successful completion of the introductory HCI courses (e.g., CPSC 344 or 544)

Summer 2017

Ivan Beschastnikh

Project 1: Analysis of distributed systems

Mutation testing is a strategy for evaluating the efficacy of a test suite. You change, or mutate, the subject program and then see if the test suite finds the change (by failing). We are developing a mutation testing framework for distributed systems. If you like program analysis and/or distributed systems, then this project is for you.

Project 2: Cloud computing

OpenStack is a cloud platform that allows enterprises to run a personal cloud. We are extending OpenStack to include several low-level features such as bandwidth guarantees between allocated VMs.

If you want to hack on cloud computing infrastructure, then this project is for you.

Project 3: System visualization tools

We are building a variety of visualization tools to help developers better understand the behavior of their systems. For example, TSViz is a tool for visualizing traces from multi-threaded systems: https://bitbucket.org . We are working on tools for performance debugging, improving comprehension, etc. If you enjoy data visualization/program analysis and want to contribute to open source tools to help developers, then this project is for you.

Giuseppe Carenini with David Poole

Further developing an interface to support group decision making

Group ValueCharts is a visual tool intended to support groups in making preferential  choice decisions (i.e., select the best alternative out of a set, with respect to some criteria). This project will focus on extending Group ValueCharts to make it more robust and usable by exploring different visual encodings, layouts and interactive techniques. Revisions of of the current prototype will be driven by feedback from current users and by A-B user studies that will need to be designed and run.

Cristina Conati

Improving and Testing an Eye Tracking Data Processing Library

Supervisor: Prof. Cristina Conati   - conati@cs.ubc.ca

The overall goal of this project is to devise intelligent user interfaces that can track their users’ gaze and use it to infer user states relevant to personalize the interaction (e.g., user attention level, confusion, engagement, cognitive abilities).

EMDAT (Eye Movement Data Analysis Toolkit) is a python library being developed in our research laboratory for analyzing user eye gaze and pupil data in terms of a wide variety of features that can be leveraged for predicting user states. We are looking for a USRA who will help  test and further develop EMDAT. EMDAT has dozens of configuration parameters which dictate how raw eye tracking data is processed. Given this complexity, we require help implementing extensive testing regarding the correctness of EMDAT functionality across many different parameter configurations, as well as compiling results on the impact of the range of each parameter setting within or between datasets. The student will then be involved in enhancements of the current EMDAT library,  based on the results of the testing process. The student will work closely with PhD student Dereck Toker (dtoker@cs.ubc.ca) and Postdoctoral Fellow Sebastien Lalle (lalles@cs.ubc.ca).

Michael Friedlander

Project 1: # Collaborative Resistance

How do we measure the "distance" between two people in a network? We might borrow a notion from electrical networks, which measures the electrical resistance between two components on a network, in order to determine the relatedness of people in a social network.  This project aims to apply these ideas to compute the similarity between academics on the network implied by co-authorship on academic papers. The work involved in this research requires several steps: assembling a data set, implementing numerical algorithms to compute the resistance distances between authors on the network, and developing visualization tools that can be used to explore the results.

Applicants should have familiarity with a numerical-computing language (e.g., Julia or Matlab), a background in linear algebra (e.g., CPSC302 or 402), and some experience with web development.

Project 2: Numerical algorithms in Julia

Software implementation of numerical algorithms is one of the very best ways of transferring mathematical ideas into practice. For software implementations to be useful, they need to efficient and robust. The aim of this project is to assemble a library of numerical algorithms in Julia — a high-level, high-performance technical computing language (https://julialang.org/). This project requires someone already familiar with a high-level language (such as Python or Matlab), and interest in numerical algorithms and their implementation.

Thomas Fritz 

Project 1: Sensing Code Difficulty

Biometric sensor technology offers the opportunity to measure physiological features of a person, such as the pupil dilation or brain wave activity, that can then be linked to the person's cognitive and emotional states. Initial results from previous studies show that biometric data can be used to predict the code and task difficulty a software developer experiences while working. In this project, you will develop an approach that collects, processes and analyzes biometric data captured with an eye-tracker in real-time to predict the difficulty of the code elements a software developer is working with.

Project 2: Awareness of Interactions at Work

Interruptions of knowledge workers are common and can cause a high cost if they happen at inopportune moments. One of the most costly kind of interruptions are in-person interruptions due to their high frequency and immediate nature. One way to reduce the high cost of in-person interruptions is to provide awareness to the knowledge workers. In this project, you will develop an approach that (a) uses a microphone to capture and identify in-person interruptions of a knowledge worker and (b) provides a visualization of the number of interruptions and the length of the interactions to the knowledge worker.

Alan Mackworth with David Poole

AIspace2 with Alan Mackworth and David Poole. AIspace (see http://aispace.org) has been developed by USRA students and grad students over a number of years. There are two aspects of the job. The first is to fix some of the bugs in the existing tools (written in Java). We have written many of the AI algorithms in open-souce Python, and the second task is to integrate the code with interactive visualizations (e.g., in D3) that are easy for students to extend and allow the students to modify the AI algorithms. Skills required: proficiency in Java and Python, the ability to write clear and simple code.

Ian Mitchell

Project 1: Numerical Software Development for Differential Equations

Research on robotics and cyber-physical systems often involves approximating the solution of differential equations which model the physical system being studied. The goal of this project would be to demonstrate on a new example, improve the user interface of, validate the implementation of and/or add features to one of several software packages used for approximating sets of solutions in order to demonstrate the correctness of robotic or cyber-physical systems. The Toolbox of Level Set Methods is a locally developed example, but others include SpaceEx or CORA.  Applicants should be familiar with Matlab and numerical ODE solvers (for example, CPSC 303 or Math 405).

Project 2: Collaborative control scheme design, simulation and testing for a smart wheelchair

Among the projects of the CanWheel collaboration and AGE-WELL Network Center of Excellence is investigating techniques which would allow elderly individuals with mild cognitive and/or sensory impairments to better use powered wheelchairs.  While it is relatively easy to implement a system in which either the user or the robotics chooses the motion of the wheelchair, it is much more challenging to blend these two inputs in real-time and in a manner which is both safe and non-threatening to a cognitively impaired user.  As part of this process, the team runs user studies with the target population and their therapists in long term care centers. Goals for this summer's project include setting up a virtual reality workstation for trials of collaboration control policies, data collection and analysis from real-world and virtual trials, and ongoing  prototype development and evaluation of collaboration and training interfaces and control policies.  Applicants should be familiar with C++, Matlab and/or Python, and will be expected to learn and use ROS (robot operating system) to program the wheelchair(s).

Michiel van de Panne

Deep Reinforcement Learning for Physics-based Models of Movement

In our research group, we are developing interactive and responsive physics-based simulations of human and animal movement. The primary challenge is that of learning motor skills, i.e., how to drive the movement of the joints over time so as to achieve skilled movement. This can be used to drive digital humans (and other animals) for computer animation, as well as providing relevant insights for robotics and biomechanics. Over the past two years, we have developed highly-capable solutions based on deep reinforcement learning. We are looking to further build on our methods and results over the summer. Directions include: (a) developing web-based demonstrations for these state of-the-art models; (b) developing learned predictive (kinematic) models of movement that capture the combined effect of the learned control and the physics-based simulation; and (c) learning control models that are parameterized for anthropometry, i.e., that are suitable for characters having a wide range of proportions.  Useful skills include knowledge of machine learning, deep learning, reinforcement learning, physics-based simulation, C++, and experience in using compute clusters. A passion and appreciation for skilled movements of all kinds (simulated and real) is also hugely helpful.

Summer 2016

Ivan Beschastnikh
Project 1: Securing data access with ARM TrustZone
The ARM architecture includes a new standard called TrustZone that can be used to run two operating systems side-by-side: a trusted OS, and a normal/untrusted OS. In this project you will contribute towards an ongoing large systems project whose goal is to design a new trusted OS and extend the file system with per-file security policies that are evaluated in the trusted OS. The resulting system will support scenarios in which file access can be controlled through a rich set of security policies. For example, the device GPS location can determine file access permission. An ideal candidate would have taken operating systems and is interested in reading and writing low-level systems code.

Project 2: Managing assertions in complex systems
Assert statements are used extensively in large systems codebases, such as Linux. However, today's developers manually maintain thousands of assert statements without much tool support. In this project you you will contribute towards a project whose goal is to develop a suite of tools to help systems developers manage assert locations and assert predicates in large codebases. This project will span multiple research areas, including software engineering, software analysis, compilers, and operating systems.

Project 3: Refactoring state out of network middleboxes
The virtualization of network functions is prompting a re-think of traditional network architectures. Middleboxes, such as NAT boxes and firewalls, long considered "architectural barnacles", have received significant attention. In this project you will contribute towards ExMB, a new architecture in which middlebox state is maintained in an external special-purpose data store. ExMB virtualizes middlebox state, which means that middleboxes can now be deployed as virtual instances managed by an unified control plane. An ideal candidate would have experience with networks and/or operating systems.

Project 4: Mining temporal program properties without templates
Specification inference tools infer a specification, like a finite state machine or a logical formula, from a set of executions of a program (i.e., positive examples). In this project the student will extend an existing temporal specification mining tool called Texada ( https://bitbucket.org/bestchai/texada/ ) with the ability to mine properties without relying on templates. The core of the project will combine genetic algorithms with Texada's existing temporal property mining algorithms. An ideal student would have a strong discrete math/algorithms background.

Michael Friedlander
Numerical algorithms in Julia
Software implementation of numerical algorithms is one of the very best ways of transferring mathematical ideas into practice. For software implementations to be useful, they need to efficient and robust. The aim of this project is to assemble a library of numerical algorithms in Julia, which is a high-level, high-performance technical computing language (https://julialang.org/). This project requires someone already familiar with a high-level language (such as Python or Matlab), and interest in numerical algorithms and their implementation.

Jim Little
This research project supervised by Prof. Jim Little in the Laboratory for Computational Intelligence in Computer Science at UBC is directed at understanding human activities, specifically understanding broadcast sports videos, particularly, ice hockey and basketball. (See https://www.cs.ubc.ca/~shervmt/) We aim to build a system that allows coaches to analyze games, sports viewers to replay their own view of the game, selecting the players and sequences of types that interest them, and in general allows people to understand the game at many semantic levels. We aim moreover to identify players, their roles, and how the players interact over time and space. The technical challenges include handling moving cameras, low resolution imagery, and rapidly moving players. Several fundamental problems must be addressed: rectification of images taken by panning, tilting, and zooming cameras; motion recognition; player tracking; player identification. Our recent work builds on strong advances in tracking and recognition and targets general semantic understanding of the game. The project includes many aspects of vision: projective geometry, machine learning, online estimation, modeling of geometry and appearance. We build systems that solve concrete tracking and identification problems via strong implementations and exploratory theories. The software for the project is implemented in several languages, including C++, Matlab, and increasingly Python. Specific language experience is desirable but not necessary, however programming maturity is essential. A student working in the project will acquire both software development experience and modeling skills, in an active group of collaborating graduate students researching all aspects of the project. We have weekly meetings to discuss topics related to video understanding, and other weekly meetings on robotics and vision (/labs/lci/robuds/).

Karon MacLean
Project 1: Macaron - software (and hardware) development
Supervisor: Prof. Karon MacLean (SPIN Lab) - maclean@cs.ubc.ca
Grad Mentor(s):  Oliver Schneider <oschneid@cs.ubc.ca>

Description: Macaron (hapticdesign.github.io/macaron) is an online haptic editor, enabling artists and designers to create vibrations for wearables. Macaron is currently in beta, but we hope to reach an initial release in 2016. This project is to support production and release of a fully web-deployed Macaron editor.

In the future, there is room for involvement beyond the web development - interaction design, user studies and feedback, hardware development for demos, and extension to other devices like the CuddleBit or Arduino

USRA: Student will help develop the application, design and implement improvements to the user interface, and may help with studies and testing.

Required skills: Web/javascript, git, software engineering.
Optional skills: User study design/execution (CPSC 344, 444); sound/audio, basic hardware (soldering, simple sewing)

Other:

  • Comfortable with hardware tinkering - can’t be afraid of it.
  • Good work management and problem solving skills; able to handle working with a very strong, engaged but distributed team.

Project 2: DIY Fabric Touch Sensor Design: Requirements, Construction, Test
Supervisor: Prof. Karon MacLean (SPIN Lab) - maclean@cs.ubc.ca
Grad Mentor(s):  Laura Cang <cang@cs.ubc.ca>

1-liner: Construct fabric touch sensors of varying resolution, out of available electrically conductive striped fabric samples; compare with existing sensor models, with collection of user touch data.

Description:This projects relates to SPIN Lab’s ongoing research in creating and understanding “emotionally intelligent” social robots. Our immediate objective is to support affectively (emotionally) realistic interactive behaviours with realtime touch gesture sensing and interpretation on flexible, moving surfaces, with appropriate robot responses.

Here: Optimal resolution for a flexible affective-touch gesture recognition is hard to specify a priori, because of the many different types of touches that people use in this context. We have acquired 2 different types of electrically striped (“zebra”) fabrics which could be made into flexible fabric touch sensors of 3 different resolutions. Experimentation is required to determine how these different sensors compare to our current configuration.  The lab has built several such sensors in the past, and has considerable experience in their construction. Note: this project is ideal for someone who’s a bit crafty! Sewing machine involved.

USRA: A one-term undergraduate project will involve one or more of the following, depending on skills, interest, and stage we’ve gotten to by the time the project starts: Following sensor design practices already developed in the lab, detail-design and physically construct  three new sensors from zebra fabric. Collect gestural touch data. Record polling time, resolution changes, etc, and analyze against specifications.

Requirements:
1. Familiar with sewing and/or related hands-on, craft-type skills
2. Arduino/C - for building sensor and collecting touch data
3. HCI: For data collection stage, strong performance in CPSC 344 or equivalent; 444 preferred (quantitative study involved). Interest and experience in simple user study design important
4. Matlab: for analysis of results
5. Optional: ML, Weka: higher order analysis of touch data
6. Other: Good work management and problem solving skills; able to handle working with a very strong, engaged but distributed team.

Other: 

  • Comfortable with hardware tinkering - can’t be afraid of it.
  • Good work management and problem solving skills; able to handle working with a very strong, engaged but distributed team.

Project 3: Extract Emotional Intent from Touch-sensed Data - Data collection and/or ML Analysis
Supervisor: Prof. Karon MacLean (SPIN Lab) - maclean@cs.ubc.ca
Grad Mentor(s):  Laura Cang <cang@cs.ubc.ca>, Paul Bucci <pbucci@cs.ubc.ca>

1-liner: Design a simple study to collect touch data from participants expressing emotional intent (i.e. "make the robot feel anger”), then analyze the data using ML techniques. Project may include one or both of these two elements.

Description: This projects relates to SPIN Lab’s ongoing research in creating and understanding  “emotionally intelligent” social robots. Our immediate objective is to support affectively (emotionally) realistic interactive behaviours with realtime touch gesture sensing and interpretation on flexible, moving surfaces, with appropriate robot responses.

Here, We wish to compare how machine recognition compares to human recognition of emotional intent (Hertenstein 2006). Following up on a number of studies in SPIN lab where we examine human touch of a sensor-covered furry robot, in this study variant we wish to specifically look at the case where individuals are trying to generate a particular emotion in the robot.

USRA: A one-term undergraduate project will involve one, or ideally two-three of the following, depending on skills, interest, and stage we’ve gotten to by the time the project starts: (a) designing a data collection method adapted from Hertenstein paper, (b) collecting the data, and (c) analyzing it.

Requirements:
1.HCI: For data collection stage, strong performance in CPSC 344 or equivalent. Interest and experience in simple user study design important
2. Machine Learning, Weka:For analysis stage, strong performance in at least an introductory ML course is required.
3.Statistics:Knowledge of R valuable for analysis.
4.Other:Good work management and problem solving skills; able to handle working with a very strong, engaged but distributed team.

Ian Mitchell
Projec 1: Numerical Software Development for Differential Equations
Research on robotics and cyber-physical systems often involves approximating the solution of differential equations which model the physical system being studied.  The goal of this project would be to demonstrate on a new example, improve the user interface of, validate the implementation of and/or add features to one of several software packages used in the lab; for example, the Toolbox of Level Set Methods [/~mitchell/ToolboxLS/] and the Ellipsoidal Toolbox [http://systemanalysisdpt-cmc-msu.github.io/ellipsoids/].  Applicants should be familiar with Matlab and numerical ODE solvers (for example, CPSC 303 or Math 405).

Projec 2: Collaborative control scheme design, simulation and testing for a smart wheelchair
Among the projects of the CanWheel collaboration [https://www.canwheel.ca/] and AGE-WELL Network Center of Excellence [http://agewell-nce.ca] is investigating techniques which would allow elderly individuals with mild cognitive and/or sensory impairments to better use powered wheelchairs.  While it is relatively easy to implement a system in which either the user or the robotics chooses the motion of the wheelchair, it is much more challenging to blend these two inputs in real-time and in a manner which is both safe and non-threatening to a cognitively impaired user.  As part of this process, the team runs user studies with the target population and their therapists in long term care centers.  Goals for this summer's project include data collection from trials, interfacing the control software with a virtual reality wheelchair simulator, and ongoing prototype development and evaluation of collaboration and training interfaces and control policies.  Applicants should be familiar with C++, Matlab and/or Python, and will be expected to learn and use ROS (robot operating system) to program the wheelchair(s).

Project 3: Serious Games for Wheelchair Training
Many older adults are prescribed manual wheelchairs due to mobility impairments, but few receive any training in basic wheelchair skills.  We have already designed an Android tablet app which provides training videos to novice wheelchair users and monitors their practice time; however, user motivation quickly deteriorates because of the repetitive nature of the training tasks.  In this project we are investigating how to "gamify" the training process: how could we take advantage of common tricks from the video game industry to increase motivation levels for participants?  Last summer we designed two prototype games that are currently undergoing user trials; this summer we will use results from those trials to improve the game experience, add features (such as the ability to detect wheelies) and/or perform additional trials.  Applicants should be familiar with Java and will be expected to work on the Android mobile platform.

David Poole
Preference elicitation for computational sustainability with Giuseppe Carenini, Gunilla Öberg (IRES) and David Poole. One of the most challenging aspect of societal decision making (e.g., to create a more sustainable society) is to trade off the competing objectives of multiple stakeholders. We have a research prototype for exploring preferences that we need to make more user-friendly and self explanatory. Skills required: good programming and design skills; familiarity with human-computer interaction.

AIspace2 with Alan Mackworth and David Poole. AIspace (see http://aispace.org) has been developed by USRA students and grad students over a number of years. There are two aspects of the job. The first is to fix some of the bugs in the existing tools (written in Java). We have written many of the AI algorithms in open-souce Python, and the second task is to make the code more interactive and clear (without making it more complicated). Skills required: proficiency in Java and Python, the ability to write clear and simple code.

Summer 2015

Ivan Beschastnikh
Project 1
Logs generated by distributed systems are complex and unwieldy as it can be challenging to piece together logs generated at multiple hosts. Even if these logs contain ordering information, they are often still too complex for a developer to understand. In this project the student will contribute to a tool for visualizing distributed system logs that contain vector timestamps (based on the tool from project #1). The current tool visualizes a single execution as a time-space diagrams of multiple hosts. The student will extend this tool to visualize multiple executions (e.g., hundreds) in a concise and comprehensible manner.

Project 2
Test case generation is a program analysis technique that is used to generate new unit/integration tests of an application based on an existing test suite, the source code of the program, and other information. Recently, random test case generation has seen a resurgence in popularity. In this project, the student will explore ways of augmenting random test case generation with mined program invariants. For this, the student will extend Randoop, a popular random test case generation tool.

Giuseppe Carenini with Raymond Ng
The student will contribute to our work on mining, summarizing and visualizing written conversation (e.g., email, blog). An initial step may consist of combining techniques we have developed for topic modeling and rhetorical parsing to effectively perform query-based summarization. Next, we will test our framework on different conversational corpora including a blog corpus that has been recently annotated in the context of a large EU project. The project will require system development as well as running experiments and analyzing results.

Ron Garcia
Since the early days of programming, there have been dynamic languages (like LISP, Python, and BASH) that are good for rapid prototyping, and static languages (like Scala, F#, and ADA), that provide strong type systems to catch errors well before a program is deployed.  Gradual Typing is an approach to designing programming languages that blend the strengths of both styles of languages and support a seamless path from dynamic prototypes to static production code.  The goal of this project is to develop conceptual underpinnings for Gradual Typing that can help language designers evaluate how gradual their languages are, and how to gradualize languages that represent the wide range of programming paradigms.  The ideal candidate is comfortable with mathematical reasoning and has an excellent grasp of programming language design concepts, as demonstrated by strong performance in CPSC 311 for instance.

Kevin Leyton-Brown
In the next 1-2 years, the US Federal Communications Commission will conduct an innovative auction in which television stations sell their broadcast rights, remaining TV stations repacked into a smaller range of channels, and the freed radio spectrum is sold to mobile phone companies. This auction will be a big deal--it's forecast to net the government $20 billion. It also represents a very difficult computational and economic problem, chiefly because the auction design depends on repeatedly solving NP-complete problems to reason about station repackings. Our group is studying variations in the auction design and improvements to the repacking algorithm; it's extremely likely that our work will affect the practice of the real auction. We're looking for an exceptional undergraduate student to complement our team over the summer. Such a student will need a background in programming (ideally Java), machine learning, and statistics. Daily work will involve writing code, running experiments on our 160-CPU cluster, analyzing data, and modifying algorithm and auction designs as a result to achieve desired objectives.

Jim Little
This research project supervised by Prof. Jim Little in the Laboratory for Computational Intelligence in Computer Science at UBC is directed at understanding human activities, specifically understanding broadcast sports videos, particularly, ice hockey and basketball. We aim to build a system that allows coaches to analyze games, sports viewers to replay their own view of the game, selecting the players and sequences of types that interest them, and in general allows people to understand the game at many semantic levels. We aim moreover to identify players, their roles, and how the players interact over time and space. The technical challenges include handling moving cameras, low resolution imagery, and rapidly moving players. Several fundamental problems must be addressed: rectification of images taken by panning, tilting, and zooming cameras; motion recognition; player tracking; player identification. Our recent work builds on strong advances in tracking and recognition and targets general semantic understanding of the game. The project includes many aspects of vision: projective geometry, machine learning, online estimation, modeling of geometry and appearance. We build systems that solve concrete tracking and identification problems via strong implementations and exploratory theories. The software for the project is implemented in several languages, including C++, Matlab, and increasingly Python. Specific language experience is desirable but not necessary, however programming maturity is essential. A student working in the project will acquire both software development experience and modeling skills, in an active group of collaborating graduate students researching all aspects of the project. We have weekly meetings to discuss topics related to video understanding, and other weekly meetings on robotics and vision (/labs/lci/robuds/).

Karon MacLean with Ron Garcia
CyberHap MiniMooc for learning Physics via Haptics
This NSF-funded project’s aim is to learn whether the embodied, tangible aspects of an engaged haptic (force feedback) experience can contribute to learning of physical concepts, such as force-motion relationships as taught in high school physics courses. In collaboration with Stanford robotics and education experts, we will use a low-cost 1-dimensional haptic display to evaluate this question in an educational context – initially, students from high schools in a low-income neighbourhood in the Bay Area, eventually in controlled hypothesis-driven evaluations.

SPIN Lab’s contributionwill be graphical programming tools. Learners who are not expert programmers will be too deeply distracted by the arduous task of constructing haptic simulations to actually learn. Instead, we will build a visual programming interface to support the learning goals and create a transparent, hands-on connection to the underlying hardware experience. Thislargertask involves prototyping several variants of a front-end of a graphical programming environment, based on requirements that will be drawn from a set of team-designed lesson plans and a pool of target student users and their teachers; implementing one or more best candidates, in collaboration with programming language expert Dr. Ron Garcia, and evaluating them with students and with our Stanford team.

USRA: A one-term undergraduate project will involve a responsible role (as part of a team) in the larger task described above, with specifics somewhat dependent on individual strengths and the larger project’s stage when the project begins.

Requirements:
1. Programming:Strong and extendable abilities; experience in a variety of system
  - Experience with Arduino, and/or with introductory programming language principles (e.g. CPSC 311) a plus.
2.HCI: strong performance in CPSC 344 or equivalent. Interest and experience in user requirements gathering, prototype development, and prototype evaluation with users is essential.
3.Physics: A good grasp of basic concepts.

Other:

  • Comfortable with hardware tinkering - can’t be afraid of it.
  • Good work management and problem solving skills; able to handle working with a very strong, engaged but distributed team.

 

Ian Mitchell
Numerical Software Development for Differential Equations
Research on robotics and cyber-physical systems often involves approximating the solution of differential equations which model the physical system being studied.  The goal of this project would be to demonstrate on new example, improve the user interface of, validate the implementation of and/or add features to one of several software packages used in the lab; for example, the Toolbox of Level Set Methods [https://www.cs.ubc.ca/~mitchell/ToolboxLS] and the Ellipsoidal Toolbox [http://systemanalysisdpt-cmc-msu.github.io/ellipsoids/].

Applicants should be familiar with Matlab and numerical ODE solvers (for example, CPSC 303 or Math 405).

Collaborative control scheme design, testing and data publication for a smart wheelchair
Among the projects of the CanWheel collaboration [http://www.canwheel.ca] and AGE-WELL Network Center of Excellence [http://www.agewell-nce.ca] is investigating techniques which would allow elderly individuals with mild cognitive and/or sensory impairments to better use powered wheelchairs.  While it is relatively easy to implement a system in which either the user or the robotics chooses the motion of the wheelchair, it is much more challenging to blend these two inputs in real-time and in a manner which is both safe and non-threatening to a cognitively impaired user.  As part of this process, the team runs user studies with the target population and their therapists in long term care centers.  Goals for this summer's project include visualization and analysis of data from previous trials and ongoing prototype development and evaluation of collaboration and training interfaces and control policies.

Applicants should be familiar with C++ or Python, and will be expected to learn and use ROS (robot operating system) to program the wheelchair(s).

Serious Games for Wheelchair Training
Many older adults are prescribed manual wheelchairs due to mobility impairments, but few receive any training in basic wheelchair skills.

We have already designed an Android tablet app which provides training videos to novice wheelchair users and monitors their practice time; however, user motivation quickly deteriorates because of the repetitive nature of the training tasks.  In this project we would like to investigate how to "gamify" the training process: how could we take advantage of common tricks from the video game industry to increase motivation levels for participants, and what sensors might be needed to provide feedback from the physical environment?  Applicants should be familiar with an imperative language (eg: Python, Java, C/C++, Matlab) and will be expected to work on the Android mobile platform.

Summer 2014

Ivan Beschastnikh
Project 1
A major challenge when debugging distributed systems is analyzing execution logs generated at multiple hosts. In this project the student will work on a tool that automatically generates logs of distributed system activity with vector timestamps (a type of a logical clock). The current version of the tool works on Java applications and relies on the AspectJ compiler. The student will generalize the tool to work with Python and C programs.

Project 2
Logs generated by distributed systems are complex and unwieldy as it can be challenging to piece together logs generated at multiple hosts. Even if these logs contain ordering information, they are often still too complex for a developer to understand. In this project the student will contribute to a tool for visualizing distributed system logs that contain vector timestamps (based on the tool from project #1). The current tool visualizes a single execution as a time-space diagrams of multiple hosts. The student will extend this tool to visualize multiple executions (e.g., hundreds) in a concise and comprehensible manner.

Project 3
Test case generation is a program analysis technique that is used to generate new unit/integration tests of an application based on an existing test suite, the source code of the program, and other information. Recently, random test case generation has seen a resurgence in popularity. In this project, the student will explore ways of augmenting random test case generation with mined program invariants. For this, the student will extend Randoop, a popular random test case generation tool

Project 4
Model inference tools infer a model, like a finite state machine, from a set of executions of a program (i.e., positive examples). Many of these tools require the mining of the executions to extract temporal patterns that can be used to generalize the observations to derive a more general, and compact, model. In this project, the student will develop and implement a miner for a set of tertiary temporal patterns that will be added to an existing model inference framework.

Michael Friedlander
Linear operators are at the core of many of the most basic algorithms for signal and image processing. Matlab's high-level, matrix-based language allows us to express naturally many of the underlying matrix operations---e.g., computation of matrix-vector products and manipulation of matrices---and is thus a powerful platform on which to develop concrete implementations of these algorithms. Many of the most useful operators, however, don't lend themselves to the explicit matrix representations that Matlab provides.
This project intends to continue the development of the Spot Toolbox (https://www.cs.ubc.ca/labs/scl/spot/), which aims to bring the expressiveness of Matlab's built-in matrix notation to problems for which explicit matrices are not practical. It will involve adding online documentation, and adding features to the toolbox.

Kevin Leyton-Brown
Meta-algorithmic techniques for designing high-performance algorithms
Algorithms for solving difficult computational problems play a key role in many applications. In many cases, provably efficient algorithms are unlikely to exist, and heuristic methods are the key to solving these problems effectively. However, the design of effective heuristic algorithms, particularly algorithms for solving computationally hard problems, is a difficult task that requires considerable expertise. State-of-the-art heuristic algorithms are traditionally constructed in an iterative, manual process in which the designer gradually introduces or modifies components or mechanisms whose performance is then tested by empirical evaluation on one or more sets of benchmark problems. This design problem is difficult and requires considerable expertise. The end use of existing state-of-the-art algorithms is often complicated by the fact that these algorithms are highly parameterized; end users often need to experiment with various combinations of settings in order to achieve satisfactory performance. Our research aims to design tools for automating both of these processes. In particular, we have focused on automatic algorithm design, automatic parameter tuning, and the automatic construction of algorithm portfolios that outperform their constituents. A student joining our group needs a background in programming, machine learning, and statistics. Daily work involves writing code, running experiments, analyzing data, and modifying algorithm designs as a result to achieve desired objectives.

Karon MacLean
HCI Design Project:  Customization of Tactile Feedback Notifications for Applications in Sports Training, Physical Therapy and Emoticons
The Sensory Perception and Interaction (SPIN) Research Group is developing human-computer interaction (HCI) applications in which tactile notifications provide specific information to users. In collaboration with the startup Haptok Inc, we are investigating user customization techniques for several case studies.

These involve applications where, for example,
1) a 'smart system' with sensors, e.g. of realtime interpretation of motion (developed in our lab), assists a user to achieved desired physical behavior, such as sports interval training with fine-grained and usable feedback on e.g. pace, cadence, heartrate, and even finer details of omtion; or for parameters relating to accurate execution of physical therapy activity prescriptions.

2) visual medium need to be enriched with qualitiative elements, such as emoticons (haptically expressed) in communications.

The USRA project is to assist a PhD researcher in human-computer-interaction design activities relating to *customization* of these applications, to develop engaging and usable ways to choose from extensive alternatives to get results that work for a particular individuals preferences and needs.

The ideal candidatewill have taken CPSC 344 (Introduction to User Interface Design) or its equivalent. You will be  comfortable with a range of visual mockup tools and techniques, principles of HCI design, and running evaluations in support of design.

This work will be conducted in collaboration with Haptok Inc., a startup emerging from SPIN, which has interest in this problem. A student who does well on this project may have potential for further involvement with this emerging company.

Joanna McGrenere
The following projects are available with Joanna McGrenere’s research team. An undergrad student could work on one (possibly two) of these projects this summer. The ideal candidate would have knowledge of user interface design, as well as some experience running user studies (CPSC 344 or equivalent) and doing quantitative analysis (CPSC 444 or equivalent).

Project 1: Cognitive Testing on a Computer
Cognitive Testing on a Computer (C-TOC) is a computerized screening test for cognitive impairments that older individuals can take independently at home without the presence of a health professional. Currently in Canada, the average wait time for a consultation in a clinical setting regarding cognitive concerns ranges between 6 and 24 months during which cognitive performance can degrade further. C-TOC would assist in detecting early signs of cognitive impairments for test-takers at home so that they can acquire medical attention faster.

We are looking for a student to help with various aspects of C-TOC, which includes but is not limited to porting a desktop version of C-TOC (operated by the mouse) to one that runs on a tablet (touch based). We will be exploring touch interaction for older adults, both by reading the literature but also thinking towards user studies with older adults that evaluate touch-based gestures. The goal will be to redesign and re-implement C-TOC for this platform and interaction modality. We also have a number of ongoing user studies with older adults, including one that is looking at the impact of interruptions (e.g., a phone call) on C-TOC performance. A student would assist in running the study and analyzing the data collected.

This project involves working with a multi-disciplinary team from Computer Science and Medicine.

Project 2: Touch Interaction on Mobile Devices for Users Across the Adult Lifespan
As the use of mobile devices grows, there is a critical need to understand how users touch and type on touchscreens under common problematic physical scenarios such as walking or in a moving vehicle. This project's goal is to explore touch interaction on mobile devices with the hopes of creating adaptive interfaces that improve touch accuracy for users of all ages, skill and physical context. We are looking for a student that can help us design and run user studies that explore touch interaction for users spanning the adult lifespan. Additionally, the student would assist in data management and analysis as a necessary precursor to the design of interfaces that adapt to the user and their environment.

Project 3: Personalization in Personal Task Management
Personalizable systems provide mechanisms through which users can make changes to the system (customize it)  to better fit their purposes/needs. These mechanisms include choosing between a set of options, using a form of construction set to construct new functionality, and scripting or directly changing the source code. The first approach is limited mainly due to the difficulty of predicting alternative options that users might need in the future, at the design time. The last approach requires the user to have some knowledge of programming. We are exploring different aspects of the construction set approach in the task management domain to address questions such as: What elements should the construction set include? What are the mechanisms through which users can assemble these elements for creating new functionality? What communication mechanism should the system provide to facilitate sharing of personalizations that are performed with this approach? A student would assist in implementing some of the mechanisms that we have prototyped and/or in running a user study to assess how well users are able to use such mechanisms to make their desired changes to a task management system.

Ian Mitchell
Automated parameter discovery for the Toolbox of Level Set Methods
The Toolbox of Level Set Methods [www.cs.ubc.ca/~mitchell/ToolboxLS/] is a collection of Matlab routines for dynamic implicit surfaces and approximating the solution of the Hamilton-Jacobi partial differential equation (PDEs).  New users often have trouble running their first simulations because there are a large number of parameters that must be correctly set; for example, the extent and resolution of the computational domain.  The goal of this project is to automatically determine appropriate settings for these parameters and construct a simple graphical interface by which new users could propose systems, run simulations and see how the parameters are set.  Applicants should be familiar with Matlab and numerical integrators for ODEs; familiarity with PDEs is not necessary.

Control synthesis from nonsmooth interpolants under uncertainty
There are many approaches to solving path planning and related optimal control problems for robots that involve discretizations of the state space; for example, structured grids or rapidly exploring random trees.  Interpolation is required when it comes time to implement the resulting path because the robot's state never precisely aligns with a sample in the discretization.  Simplistic interpolation, such as nearest neighbour, is often used because more accurate techniques lead too easily to numerical instability.  The goal of this project is to construct an accurate but stable interpolation scheme for such problems, hopefully one which also takes into account cases where the robot's state is uncertain.  Applicants should be familiar with Matlab, Python and/or C++, and will learn a variety of path planning and simulation algorithms for robots.

Collaborative control scheme design, testing and data publication for a smart wheelchair
The CanWheel collaboration [http://www.canwheel.ca] is investigating techniques which would allow elderly individuals with mild cognitive and/or sensory impairments to better use powered wheelchairs.  As part of this process, the team ran a "Wizard of Oz" study in which such individuals interacted with a power wheelchair while a human (the wizard) simulated a variety of collaborative control schemes that the chair might eventually use -- such a study allows us to identify promising interface approaches without having to implement all the sensory and planning software infrastructure in advance.  The goal of this summer's project is to help implement and test automated prototypes of the most promising interfaces identified by the earlier trials, as well as organize and publish sensor data from those and newer trials.  Applicants should be familiar with C++ or Python, and will be expected to learn and use ROS (robot operating system) to program the wheelchair.

Serious Games for Wheelchair Training
Many older adults are prescribed manual wheelchairs due to mobility impairments, but few receive any training in basic wheelchair skills.  We have already designed an Android tablet app which provides training videos to novice wheelchair users and monitors their practice time; however, user motivation quickly deteriorates because of the repetitive nature of the training tasks.  In this project we would like to investigate how to "gamify" the training process: how could we take advantage of common tricks from the video game industry to increase motivation levels for participants, and what sensors might be needed to provide feedback from the physical environment?  Applicants should be familiar with an imperative language (eg: Python, Java, C/C++, Matlab) and will be expected to work on the Android mobile platform.

Raymond Ng
Topic segmentation and labeling of conversation data. The key milestones are: (i) the development of robust topic segmentation for multimodal conversations; and (ii) abstractive topic labeling for conversations.

Rachel Pottinger
IDEASS (https://ideass.civil.ubc.ca/) is a interdisciplinary project to support better building and community planning processes by understanding the interaction between the various processes and the data involved in each part of the process.  In this project, the student will work along with graduate students to help create a test suite of data that can help the researchers determine how to better help building designers and regional planners.

Desirable skills include the need to understand SQL.  Some understanding of spatial data is a plus but not required.

Summer 2013

Bill Aiello and Robert Bridson

Dynamic tetrahedral meshing with acute lattices
One of the most successful class of algorithms for generating quality tetrahedral meshes is to overlay a regular lattice (typically from a grid or octree) over the domain of interest, and with careful cutting and warping fit it to the boundary of the domain. We look to extend this approach in two ways. First, to robustly match both sharp and smooth parts of the domain boundary appropriately (as past methods have concentrated on just one or the other), and second to build an adaptive (octreee-like) extension of an existing acute tetrahedral tiling which offers significantly better quality output meshes in our preliminary results. Furthermore, we wish to exploit this capability by dynamically remeshing a simulated elastic solid undergoing fracture to precisely conform to the desired crack surfaces without compromising element quality, as previous methods have had to choose between. As the scope is fairly broad, the research will be in collaboration with an MSc student.

Giuseppe Carenini
The student will contribute to our work on mining, summarizing and visualizing written conversation (e.g., email, blog). An initial step may consist of improving the performance of our existing techniques for topic modeling, opinion mining and conversational analysis. Next, we will focus on developing a framework for integrating the different mining tasks, so that they can be performed simultaneously and interdependently. To achieve this goal, we will explore Markov Logics and possibly other AI formalisms.

Will Evans and David Kirkpatrick
Will Evans and David Kirkpatrick are interested in jointly sponsoring/supervising a highly motivated student interested in gaining research experience in algorithm design and analysis. We have a variety of concrete topics that would be suitable for a summer research project. However, we are also very willing to work out the details of a project that will incorporate the particular interests of the research student.

The following list is incomplete, but should provide an indication of the scope of possible research topics:
1) Design and analysis of algorithms whose inputs are imprecise; specifically competitive analysis under the assumption that input precision is an expensive resource.
2) Design and analysis of algorithms involving graph-theoretic and geometric models of sensor networks.
3) Graph theoretic characterization of geometric graphs such as visibility graphs.
4) Space-constrained computations and time-space tradeoffs.
5) Combinatorial aspects of certain coloured Escher tilings.
6) Algorithmic issues related to bounded-curvature motion planning.

Michael Friedlander
Linear operators are at the core of many of the most basic algorithms for signal and image processing. Matlab's high-level, matrix-based language allows us to express naturally many of the underlying matrix operations---e.g., computation of matrix-vector products and manipulation of matrices---and is thus a powerful platform on which to develop concrete implementations of these algorithms. Many of the most useful operators, however, don't lend themselves to the explicit matrix representations that Matlab provides.

This project intends to continue the development of the Spot Toolbox (https://www.cs.ubc.ca/labs/scl/spot/), which aims to bring the expressiveness of Matlab's built-in matrix notation to problems for which explicit matrices are not practical. It will involve adding online documentation, improving the installation and distribution mechanism, and adding features to the toolbox.

Karon MacLean
Over the past thirty years, robotic technology has been integrated into the manufacturing industry for the purpose of improving efficiency and reducing worker ergonomic stress and workload, but an evolving industry now requires more effective communication and collaboration between human and robot. The broad goal of our research is to develop methods of human-robot interaction (HRI) that will facilitate close cooperation between humans and robots on industrial tasks.

We are seeking an undergraduate researcher to assist with the development of HRI methods using multiple communication channels including visual signals, audio cues, and touch-based interaction. The student will design ways of communicating various ideas between a human and a robot, test these communication methods in user studies, and compare different communication methods in task-based experiments. Programming skills are required and experience with circuit design and human-robot interaction or human-computer interaction are desired.

Joanna McGrenere
The following projects are available with Joanna McGrenere’s research team. An undergrad student could work on one or more of these projects this summer. The ideal candidate would have knowledge of user interface design, as well as some experience running user studies (CPSC 344 or equivalent) and doing quantitative analysis (CPSC 444 or equivalent).

Cognitive Testing on a Computer (C-TOC) is a computerized screening test for cognitive impairments that older individuals can take independently at home without the presence of a health professional. Currently in Canada, the average wait time for a consultation in a clinical setting regarding cognitive concerns ranges between 6 and 24 months during which cognitive performance can degrade further. C-TOC would assist in detecting early signs of cognitive impairments for test-takers at home so that they can acquire medical attention faster.

In the first project, we are specifically looking into cross-cultural design in the context of C-TOC, given that it has the potential of becoming a cognitive assessment tool for older adults of various cultural backgrounds.  How should we change the interface to fit different cultural contexts? Would changing the interface culturally affect performance, satisfaction or anxiety of different cultural groups?  We have already run a study with 36 older adults in Vancouver from European and East Asian backgrounds. As a next step we are looking for a candidate to take charge of running an equivalent study on a larger scale using Amazon’s Mechanical Turk. Mechanical Turk is a crowdsourcing platform where a large pool of participants is accessible and can perform various tasks, including usability studies. The project will constitute of deploying the experiment prototype on Mechanical Turk, monitoring the experiment, collecting, organizing and analyzing data.  This will be a great opportunity to oversee the running of an HCI usability study from beginning to end as well as getting familiar with Amazon Mechanical Turk, a platform for usability studies that is burgeoning in the HCI community. We hope to gain insight to better understand the relationship between culture and HCI as well as think about how to change interface design across cultural boundaries.

In the second project, we are looking to port C-TOC from a desktop application (operated by the mouse) to one that runs on a tablet (touch based). We will be exploring touch interaction for older adults, both by reading the literature but also thinking towards user studies with older adults that evaluate touch-based gestures. The goal will be to redesign and re-implement C-TOC for this platform and interaction modality.

Students on these two projects will work with a multi-disciplinary team from Computer Science and Medicine.

Ian Mitchell
Project 1: Benchmarks for comparing optimal control and/or verification software
Research in optimal control studies the problem of finding the best way to guide a system, such as a robot, to accomplish a given task.
Verification is a related research area which seeks to demonstrate that a given system satisfies a given property.  The research literature is full of proposed algorithms in both domains, but all too often the authors use trivial and/or incomparable examples to demonstrate their techniques.  The goal of this project is to construct an online repository containing a variety of benchmark problems in one or both fields which researchers could use to compare their approaches more quantitatively.  Applicants should be familiar with Matlab, Python and/or C++, and will learn about optimal control, path planning and/or verification.

Project 2: Automated parameter discovery for the Toolbox of Level Set Methods
The Toolbox of Level Set Methods [www.cs.ubc.ca/~mitchell/ToolboxLS/] is a collection of Matlab routines for dynamic implicit surfaces and approximating the solution of the Hamilton-Jacobi partial differential equation (PDEs).  New users often have trouble running their first simulations because there are a large number of parameters that must be correctly set; for example, the extent and resolution of the computational domain.  The goal of this project is to automatically determine appropriate settings for these parameters and construct a simple graphical interface by which new users could propose systems, run simulations and see how the parameters are set.  Applicants should be familiar with Matlab, and will learn how to numerically approximate PDEs.

Project 3:  Control synthesis from nonsmooth interpolants
There are many approaches to solving path planning and related optimal control problems for robots that involve discretizations of the state space; for example, structured grids or rapidly exploring random trees.  Interpolation is required when it comes time to implement the resulting path because the robot's state never precisely aligns with a sample in the discretization.  Simplistic interpolation, such as nearest neighbour, is often used because more accurate techniques lead too easily to numerical instability.  The goal of this project is to construct an accurate but stable interpolation scheme for such problems, hopefully one which also takes into account cases where the robot's state is uncertain.  Applicants should be familiar with Matlab, Python and/or C++, and will learn a variety of path planning and simulation algorithms for robots.

Project 4:  Collaborative control scheme testing for a smart wheelchair
The CanWheel collaboration [http://www.canwheel.ca] is investigating techniques which would allow elderly individuals with mild cognitive and/or sensory impairments to better use powered wheelchairs.  As part of this process, the team is preparing a "Wizard of Oz" study in which such individuals will interact with a power wheelchair while a human (the wizard) simulates a variety of collaborative control schemes that the chair might eventually use -- such a study allows us to identify promising interface approaches without having to implement all the sensory and planning software infrastructure in advance.  The goal of this project is to help with development and debugging of the wizard's interface to control the robotic wheelchair, and then to help run the user trials (likely as the wizard) and collect and organize the resulting technical data from sensors like the joysticks, Kinect cameras, odometers, etc.  Applicants should be familiar with C++, and will be expected to learn and use ROS (robot operating system) to program the wheelchair.

Project 5:  Smartphone/Tablet Physical Activity Visualization and Classification
As part of the CanWheel collaboration [http://www.canwheel.ca] we are investigating methods of tracking the activity of study participants using smartphone technology.  We have access to a variety of data, including click logs, accelerometry, GPS and indoor localization.  The goal of this project is to help process, integrate, visualize and classify participant activity using these data streams.  The results would be used in publications and presentations for a number of related studies, and the software would be released publicly.
Applicants should be familiar with an imperative language (eg: Python, Java, C/C++, Matlab) and will be expected to learn and use Python packages for manipulation and visualization of the data on desktop computers and/or Java packages for data collection on android phones.

Andrew Warfield
Understanding Desktop Storage Workloads
Many organizations are in the process of deploying "virtual desktops"for their employees.  In this sort of environment, the computer on your desk is just a monitor, mouse, and keyboard, while the operating system and applications run in a central datacenter.  Virtual desktop (or VDI) deployments have had some fairly large uptake in industrial environments, with real-world deployments of more than ten thousand desktops.

VDI introduces some very big challenges for storage system design:humans tend to follow similar schedules, arriving at work and leaving for lunch at the same times of the day.  Worse, they are incredibly sensitive to latency and become irritated when their computers seem slow.  We are interested in understanding how much of a factor storage systems play in the performance of VDI workloads, and what changes can be made to improve them.  To help achieve this, this project will involve the analysis of storage trace data collected from a real-world VDI deployment.  The data analysis will aim to answer questions about the timing, interrelatedness, and content of information that is accessed from storage devices.