Meta FAIR Releases NeuralSet: A Python Package for Neuro-AI That Supports fMRI, M/EEG, Spikes, and HuggingFace Embeddings

Introduction

In this tutorial, you'll learn how to use Meta's NeuralSet, a Python package that bridges neuroscience and artificial intelligence. NeuralSet allows researchers to work with various brain data types like fMRI, M/EEG, and spike data, while also supporting HuggingFace embeddings. This tool is perfect for beginners who want to explore the intersection of neuroscience and AI without dealing with complex data processing pipelines.

This tutorial will guide you through installing NeuralSet, loading sample brain data, and performing basic analysis using its built-in functions. By the end, you'll have a working understanding of how to use this powerful package to analyze neuroscientific data with AI techniques.

Prerequisites

Before starting this tutorial, ensure you have the following:

• Python 3.7 or higher installed on your computer
• Basic understanding of Python programming concepts
• Access to a computer with internet connection
• Optional: Familiarity with neuroscience concepts like fMRI, M/EEG, or spike data

Step-by-Step Instructions

1. Install NeuralSet Package

The first step is to install the NeuralSet package using pip. Open your terminal or command prompt and run the following command:

pip install neuralset

This command downloads and installs the NeuralSet package along with its dependencies. The package will be ready for use in your Python environment.

2. Import Required Libraries

Now that NeuralSet is installed, let's import the necessary libraries in Python. Create a new Python file (e.g., neuralset_tutorial.py) and add the following code:

import neuralset as ns
import numpy as np
import pandas as pd

Here, we import NeuralSet, NumPy (for numerical operations), and Pandas (for data handling). These libraries will be essential for working with brain data.

3. Create Sample Brain Data

Before working with real brain data, let's create some sample data to understand how NeuralSet works. We'll create a simple dataset representing fMRI data:

# Create sample fMRI data
sample_fmri_data = np.random.rand(100, 50)  # 100 time points, 50 brain regions

# Create sample labels
sample_labels = np.random.choice(['rest', 'task'], size=100)

# Create a DataFrame for easier handling
fmri_df = pd.DataFrame(sample_fmri_data)
fmri_df['label'] = sample_labels

print("Sample fMRI data shape:", fmri_df.shape)
print(fmri_df.head())

This code creates random fMRI data with 100 time points and 50 brain regions, along with corresponding labels. We're simulating what real fMRI data might look like, where each row represents a time point and each column represents a brain region.

4. Load Data into NeuralSet

Now we'll load our sample data into NeuralSet's data structure:

# Load data into NeuralSet
neural_data = ns.load_data(fmri_df, data_type='fmri')

print("Data loaded successfully!")
print("Data type:", type(neural_data))

The load_data function in NeuralSet takes our DataFrame and specifies that it's fMRI data. This function prepares the data for further analysis by NeuralSet's algorithms.

5. Apply HuggingFace Embeddings

One of NeuralSet's key features is its ability to work with HuggingFace embeddings. Let's demonstrate how to use this feature:

# Create sample text data for embeddings
sample_texts = [
    "The brain processes visual information",
    "Neural networks learn from data",
    "fMRI measures brain activity"
]

# Apply HuggingFace embeddings
embeddings = ns.get_embeddings(sample_texts)

print("Embeddings shape:", embeddings.shape)
print("First embedding:", embeddings[0][:5])  # Show first 5 values

This step shows how NeuralSet can integrate natural language processing with neuroscience data. HuggingFace embeddings convert text into numerical vectors that can be used alongside brain data for analysis.

6. Perform Basic Analysis

Let's perform a simple analysis using NeuralSet's built-in functions:

# Calculate basic statistics
mean_activity = ns.calculate_mean(neural_data)
std_activity = ns.calculate_std(neural_data)

print("Mean activity across brain regions:", mean_activity[:5])  # Show first 5 values
print("Standard deviation:", std_activity[:5])

These functions help analyze the basic characteristics of our brain data. The mean and standard deviation give us insights into how brain activity varies across different regions.

7. Visualize Data (Optional)

NeuralSet also supports visualization of brain data:

# Create a simple plot of brain activity over time
import matplotlib.pyplot as plt

# Plot first 10 brain regions
plt.figure(figsize=(10, 6))
for i in range(10):
    plt.plot(neural_data[:, i], label=f'Brain Region {i}')

plt.xlabel('Time Points')
plt.ylabel('Activity Level')
plt.title('Brain Activity Over Time')
plt.legend()
plt.show()

This visualization helps understand how brain activity changes over time across different brain regions. The plot shows activity levels for the first 10 brain regions over time.

8. Save Processed Data

Finally, let's save our processed data for future use:

# Save processed data
ns.save_data(neural_data, 'processed_brain_data.npy')

print("Data saved successfully!")

This step ensures that your processed data is preserved for future analysis or sharing with colleagues.

Summary

In this tutorial, you've learned how to use Meta's NeuralSet package to work with neuroscientific data. You've installed the package, loaded sample brain data, applied HuggingFace embeddings, performed basic analysis, and visualized results. NeuralSet provides an accessible way for beginners to explore the intersection of neuroscience and artificial intelligence.

The package simplifies complex neuroscientific data processing by offering intuitive functions that handle various data types including fMRI, M/EEG, and spike data. Its integration with HuggingFace embeddings opens up new possibilities for combining natural language processing with neuroscience research.

While this tutorial used sample data, the same principles apply to real brain data. As you continue exploring NeuralSet, you can apply these techniques to actual research datasets and contribute to the growing field of neuro-AI.