Page tree
Skip to end of metadata
Go to start of metadata

The Google Summer of Code program provides a stipend for university students who want to spend a summer contributing code to open-source projects. Open Ephys participated as a mentoring organization in 2016, but we were not accepted for the 2017 program. We'll try again in 2018. Until then, this page will serve as a list of projects that would be extremely beneficial to our user base. 


1. Julia plugin module

Description: Creating custom processing modules for the Open Ephys GUI currently requires knowledge of C++. However, most scientists prefer to write code in high-level languages, such as Python and Matlab. Julia is a relatively new language for scientific computing that combines a syntax similar to Matlab with the speed of compiled C++. It's easy to call Julia code from a C++ application using the Julia C++ interface. In order to take advantage of the vast amount of signal processing code that's been written by neuroscientists, and to make it easier for users to modify the GUI, we'd like to make it possible to run Julia code directly within our software. Julia modules could be used for such applications as detecting patterns in spiking activity or performing spectral analysis on neural signals. We already have a working minimal prototype (https://github.com/open-ephys/gui/tree/jvoigts), but it needs to be made more robust and user-friendly.

Skills required: Proficiency with C++, especially integrating it with other languages

Level of difficulty: Moderate

Potential mentors: Josh Siegle (@jsiegle), Jakob Voigts (@jvoigts), Aarón Cuevas López (@aacuevas)

 

2. Event-triggered averaging module

Description: One of the most important paradigms in neuroscience involves computing the average neural response to multiple presentations of the same environmental stimulus. This type of analysis is typically done offline, but it's often more convenient to measure the average response in real time. Open Ephys users would greatly benefit from having a plugin module that could align data to external events, and display both the individual trials and the average in an elegant way. This could be part of the existing LFP Viewer, or part of a separate processor. The module should be flexible enough to trigger only on certain types of events, and to work with multiple user-defined channel groups simultaneously. Ideally, the plugin would also perform simple analyses: e.g., computing the maximum, minimum, and standard deviation of the trigger-aligned data.

For a variant: event-triggered spectrogram or event-triggered time-frequency decompositions. These will require some careful thought about the underlying library, OR a very close integration with, e.g., the Julia plugin described above.

Skills required: Proficiency in C++, basic signal processing background

Level of difficulty: Moderate

Potential mentors: Josh Siegle (@jsiegle), Jakob Voigts (@jvoigts), Aarón Cuevas López (@aacuevas), Alik Widge (Alik Widge)


3. Behavior scoring with accelerometer data

Description: When running any type of experiment with freely behaving animals, it's often important to know what behaviour the animal is engaged in at a given time. For instance, mice could be walking around, eating, grooming, sleeping, or standing up to explore their environment. Video capture can tell us roughly where an animal is located and where it's moving, but determining whether a mouse is sitting still, sleeping, or eating is very difficult with image data alone. The headstages used by Open Ephys to acquire neural data also include small accelerometers that continuously measure 3D acceleration data. Mining this data to determine the behavioural state of an animal in real time would enable scientists to perform much more targeted experiments. We're looking for someone to create a plugin module for the Open Ephys GUI that takes 3 channels of accelerometer data and classifies it into discrete states that correspond to different behavioral states of an animal.

Skills required: Proficiency in C++, knowledge of basic machine learning algorithms (to be implemented in Python, Julia, or C++)

Level of difficulty: Hard. A more modest version might be to implement the simple calibration and scalar-decoding algorithm at http://www.intantech.com/files/Intan_RHD2000_accelerometer_calibration.pdf .

Potential mentors: Josh Siegle (@jsiegle), Jakob Voigts (@jvoigts), Aarón Cuevas López (@aacuevas), Alik Widge (Alik Widge), Eric Burguiere (ICM, Paris)

 

4. OpenBCI integration

Description: The majority of Open Ephys users are academic researchers performing experiments on animal models. However, the flexibility of the Open Ephys GUI would make it ideal for working with data from humans as well. Although the Open Ephys acquisition board can be adapted for use with human EEG, there are better alternatives out there. OpenBCI is a widely used open-source platform for streaming EEG data to a computer. Enabling the Open Ephys GUI to interface with OpenBCI hardware would allow our software to reach a much wider audience. We'd like to create a source module that could receive data from a 16-channel OpenBCI board. Next, existing visualization modules (such as the LFP Viewer) should be optimized for use with EEG data. In addition, modules for spectral analysis and machine learning could be created to respond to changes in brain state in real time.

Skills required: Proficiency in C++, familiarity with microcontrollers and USB serial communication

Level of difficulty: Hard

Potential mentors: Josh Siegle (@jsiegle), Jakob Voigts (@jvoigts), Aarón Cuevas López (@aacuevas)

 

5. Improving the spike-sorting module

Description: The majority of Open Ephys users employ multi-channel extracellular electrodes, such as tetrodes or silicon probes. In order to identify the activity of individual neurons in the data coming off such electrodes, spike-sorting methods need to be used. Traditionally, spike sorting was performed offline after the experiment, but for virtually all online analyses based on spike patterns, spike sorting needs to be performed in real time. The Open Ephys GUI already has a module that performs simple spike-sorting (https://github.com/open-ephys/plugin-GUI/tree/master/Source/Plugins/SpikeSorter), but it needs both user interface and under-the-hood improvements. Further, the module currently only works with purely manual clustering, which is increasingly less viable because the number of channels recorded with modern probes exceeds what a human experimenter can manually process in the time required for a single recording. Integrating automated or semi-automated spike sorting methods methods into the Open Ephys GUI would increase its usefulness for high-channel count experiments.

Skills required: Proficiency in C++, experience designing user interfaces, knowledge of basic machine learning algorithms (ideally implemented in C++, but Python or Julia could also work here)

Level of difficulty: Hard

Potential mentors: Josh Siegle (@jsiegle), Jakob Voigts (@jvoigts), Aarón Cuevas López (@aacuevas)

 

6. Remote computing plugin

Description: The Open Ephys system allows users to record responses from up to hundreds of neurons at the same time. This can yield high-dimensional data with a rich and dynamically changing statistical structure that reflect how an animal processes sensory input, creates perception, or guides behaviour. Decoding and dimensionality reduction techniques are powerful tools to extract and visualize information carried by all recorded neurons. However, these methods are computationally expensive, often requiring more processing power than available on a typical recording computer. The goal of this project is to develop a plugin for the Open Ephys software that can send data over Ethernet to be processed in real-time on another computer (e.g., multi-processor workstation or GPU cluster). This will involve efficient transmission of user-selected data and retrieving of the data on the client side. The successful applicant will gain expertise in recent network communication architectures that form the basis for many distributed computing systems.

Skills required: Proficiency in C++, basic knowledge of network protocols, optional: basic knowledge of one or more scripting languages, e.g., Python, Matlab, or Julia (to develop example clients)

Level of difficulty: Moderate to hard

Potential mentors: Arne Meyer (UCL Gatsby Unit, London), Gonçalo Lopes (@glopes)


7. Video tracking integration

Description: Many experiments require measurements of neural activity to be integrated with measurements of animal behavior. For instance, when mapping place and grid cells during spatial learning and memory tasks,  exact knowledge of an animal's location is required. The goal of this project is to make arbitrary external information from outside equipment, such as position information from real-time video trackers, automated mazes, etc available to Open Ephys in real-time. This will involve two major sub projects:


1. Create a lightweight messaging library that can accept arbitrary serialized JSON data packets from external computers using  the ZeroMQ messaging library. ZeroMQ allows users to efficiently send information between different programs or even across the network. 
2. Create a GUI plugin that uses this messaging interface to link Open Ephys software with recently developed video-based tracking software.

The project might also explore running the tracking software on a separate single-board computer, e.g., a Raspberry pi or NVIDIA Jetson TK1. This would allow users to use the same approach regardless of the operating system and machine that is used to run the Open Ephys software.

Skills required: Proficiency in C++, basic knowledge of network protocols and/or GUI programming

Level of difficulty: Moderate

Potential mentors: Arne Meyer (UCL Gatsby Unit, London), Jon Newman (@jonnew)


8. Upgrade channel selection interface (more details)

Description: Every processing module within the Open Ephys GUI includes a generic interface that allows the user to select subsets of channels for editing parameters and toggling recording on and off. Currently, users can only select or deselect one channel at a time, and the interface does not scale well to high channel counts. We're looking for someone to re-design the interface so that the buttons for each channel can be visualized more effectively and channel selection can be performed more efficiently. This project could also include an improved display and UI for managing the passage of data between modules: Sometimes large numbers of data channels are passed from one module to the next, but sometimes individual channels or groups of channels need to be split off or combined. 

Skills required: Proficiency in C++, experience designing user interfaces

Level of difficulty: Easy

Potential mentors: Josh Siegle (@jsiegle), Jakob Voigts (@jvoigts), Aarón Cuevas López (@aacuevas), Alik Widge (Alik Widge)


9. Mathematical Operations

Description: Many real-time neuroscience applications require minor mathematical transforms. Channels may need to be subtracted to create local bipolar derivations. Multiplying channels by weight vectors and summing them is a classic neural decoding algorithm. One variant of these multichannel operations is already implemented as a Common Average Re-Reference plugin. This interface would be a module that applies very simple multichannel operations to transform data, possibly allowing the user to specify some parts (like a weight vector) in a separate file.

Skills required: Proficiency in C++, experience designing user interfaces

Level of difficulty: Easy

Potential Mentors: Alik Widge (Alik Widge)



  • No labels