Working in the LCI Lab

Research Award Opportunities

One of the most valuable research experiences for an undergraduate student is to be a research assistant. Each year, the department receives a number of research awards that help provide funding for an undergrad student to spend 16 weeks over the summer working full time in one of the department’s research labs, often with the opportunity to publish their work (see examples of previous projects.) This kind of research experience is highly sought after by graduate programs. 

All applicants must confirm their eligibility to apply and to work. You must have all necessary requirements prepared (ex. Social Insurance Number and permits).

International students must have a valid Social Insurance Number and be eligible to work on campus for the duration of the award (ex. in the summer). you will be required to provide any necessary details and documentation upon accepting the award (SURE or WLIUR). This is necessary for processing and payment. If you are offered an award but do not meet this criteria, you will not be able to accept. For questions about eligibility, please speak with an International Student Advisor.

Award Categories

The positions are available to 2nd, 3rd, and 4th year students with strong academic records. You'll find more information about the awards available, including eligibility requirements below. Watch for in-class and email announcements from the department for details and deadlines.

NSERC USRA - NSERC Undergraduate Student Research Award

SURE - Science Undergraduate Research Experience Award

WLIUR - Work Learn International Undergraduate Research Award

See the following links for more details:

NSERC Site

UBC Careers Site


How to Apply 

Deadline: February 20, 2022 at 4:00 PM

New Application Requirement: all applicants are required to apply with a confirmed supervisor. The list of projects and supervisors will be posted on this page, and you can use this to approach any of the supervisors listed. However, you aren't limited to the projects and supervisors listed below. We encourage you to directly contact professors you would like to work with to find a match. Many professors will be happy to talk to you about the opportunity to hire students at a subsidized wage. You can find our faculty directory here. For some additional tips, please see the UBC Careers page.

Student Project Submissions: This year we will be colleting student project proposals. If you have a project you would like to submit and have a faculty member supervisors please submit the online application webform.

Required Steps:

  1. Read the details above and the information at the links on this page
  2. Determine which awards you are eligible for
  3. Contact potential supervisors from the Projects and Supervisors list (see below) or by approaching Computer Science faculty members you would like to work with
  4. Once you have a confirmed supervisor, submit the online application webform by the stated deadline (the webform will become available before the deadline):
    • Before submitting, please ensure that you have read over the online guidelines, eligibility requirements, and webform instructions carefully
    • Make sure to read all of the instruction text in the webform, there may be important details noted below each field
  5. When the department is informed of how many awards are available, a departmental adjudication committee will rank the applications. All applicants will then receive a decision. If you are selected for an award, you will then receive an email with instructions to submit a new webform to provide additional information/documentation:
    • When you are applying: please read the webform carefully to ensure you are prepared to accept by providing these details
    • (Your supervisor will also be contacted for required information)

IMPORTANT:

  • All students should complete the NSERC Form 202 on the NSERC USRA website by clicking "On-line System Login" or, if you are a first-time user, "Register"
  • All students should upload a PDF of the completed NSERC Form 202 to the online application webform
  • DO NOT submit the application on the NSERC website until you have been accepted for the award and instructed to do so (at the end only students awarded for NSERC USRA will submit the application to NSERC website)
  • Instructions on how to complete the forms can be found on the NSERC USRA website 

Questions? For further details, please visit the UBC Student Services website or the NSERC USRA website and review the information and links provided, as these will likely give you the answers to your questions. If you would still like additional assistance, please see our Advising Webform instructions to see if you are eligible to submit a webform request. 


Projects and Supervisors: 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.