Last updated December 7th, 2020.
I am always looking for students to mentor—it’s one of the best parts of my job! If you’re interested in architecture and/or programming languages, take a look at the project ideas below. If any sound cool (or if you have ideas of your own) feel free to reach out to me at firstname.lastname@example.org.
I’m currently working with Andrew Liu, who helped me wrap up Bring Your Own Datatypes, and is now contributing heavily to Glenside. I’ve been lucky to mentor many other students in the past. While at Penn State, I worked with a team of motivated undergrads:
- Nelson Troncoso Aldas (pursuing PhD at PSU as of 2020)
- Christopher Pratt (pursuing Bachelor’s at PSU as of 2020)
- David de Matheu (working at Microsoft as of 2020)
- Tom Kawchak (working at Microsoft as of 2020)
We worked on developing a haptic glove and computer vision system for the visually impaired. Working with this team remains one of my fondest research memories, and it’s been awesome to see us all go on to do great things! (Not to mention, it’s been cool to have some of them also move to Seattle!)
Anything related to Glenside
Read the Glenside README and check out the Glenside issues list to see if there’s anything you want to contribute to. This is currently my main project, so you can also just reach out to me for potential ideas!
An Exploration of Custom Datatypes in Deep Learning
Using a framework
which I built on top of
the deep learning compiler TVM,
conduct a thorough investigation
of how custom numeric datatypes
affect deep learning workloads.
From fall 2018 to spring 2020,
I worked on TVM,
which is a compiler for deep learning workloads.
TVM takes in a high-level deep learning program
(written, e.g., in Tensorflow),
converts the program
to TVM’s own internal representation,
does optimizations over the program,
and compiles it down to machine code.
Onto TVM, I added a framework
that allows people to explore new
datatypes—alternatives to the 32-bit
float and 64-bit
that we are so used to.
bfloat16 and posits are great examples!)
I ran a small experiment
with this new framework,
in which I trained models in
and then converted their trained weights
to various new datatypes
to examine whether they’d retain their trained accuracy.
(It’s okay if you don’t understand any of this jargon!)
I moved on to a new project after finishing my qualifying exams, and have been looking for someone who could lead an effort to turn this into a paper!
This could mean:
- Figuring out how to train with custom datatypes
- Developing a “quantization” scheme to quantize from
float32to smaller custom datatypes (e.g. 8-bit posits)
- Exploring whether using different datatypes in different layers of a workload would ever be beneficial
- Developing a system for automatically choosing datatypes for a workload (based on power, performance, model accuracy targets)
No specific experience necessary. Familiarity with C++ and Python would be helpful!