Tutorials & Preparation Guide

Pre-Hackathon Preparation: Your Path to Success

This guide will help you prepare thoroughly for the 2026 Neuro-AI Grand Hackathon. Success depends on preparation - those who come ready will experience the miracle of 5 nights and 6 days.

1. Define Your Research Question

• Identify a specific, testable hypothesis
• Determine what “success” looks like (e.g., accuracy score, model convergence)
• Prepare a 1-page research proposal including:
  • Research objectives
  • Expected outcomes
  • Model architecture/approach
  • Success metrics

Example Good Hypothesis:

“We will develop a Transformer-based model on the ABCD dataset to verify Emotion Contextualized Perception, targeting a benchmarking score above 0.85 within 3 days.”

Example Bad Hypothesis:

“We want to analyze brain data with AI.”

2. Data Acquisition & Access

• Identify exact datasets needed (fMRI, EEG, ECoG, ABCD, etc.)
• Obtain access permissions for secure datasets
• Download datasets to local storage or cloud
• Verify data integrity and completeness

3. Data Preprocessing

• Remove noise and artifacts
• Convert to standard formats (BIDS, HDF5, etc.)
• Normalize and scale data appropriately
• Split into train/val/test sets
• Save in model-ready format (e.g., Train_X.npy, Train_y.npy)

Critical: Your data should be ready to load directly into your model on Day 1 of the hackathon!

4. Data Backup

• Store preprocessed data on external hard drive
• Upload to cloud storage (with proper permissions)
• Test data loading speed and accessibility

5. Development Environment

• GPU Access: Confirm GPU server credentials and access
• Libraries: Install and test all required libraries:

  # Example for Python/PyTorch
  pip install torch torchvision torchaudio
  pip install numpy pandas scikit-learn
  pip install nibabel nilearn  # for neuroimaging
  

• Docker: If using Docker, test container builds
• Code Repository: Set up Git repository for your team
• Collaboration Tools: Test Slack/Zoom/shared documents

6. Baseline Code

• Write and test data loading code
• Implement basic model architecture
• Test training loop with small dataset
• Verify GPU utilization and memory usage

7. Role Assignment

Define clear roles for each team member:

• Core Modeler: Develops main model architecture
• Data Engineer: Manages data pipeline and preprocessing
• GPU Specialist: Optimizes training and parallelization
• Analyst: Interprets results and creates visualizations
• Documenter: Records progress and creates presentation

8. Contingency Planning

• Discuss Plan B if primary approach fails
• Identify potential bottlenecks
• Prepare alternative models or methods
• Know who to ask for help (mentors, other teams)

fMRI Data Preprocessing Example

import nibabel as nib
from nilearn import image, masking
import numpy as np

# Load fMRI data
fmri_img = nib.load('subject_001_bold.nii.gz')

# Masking
brain_mask = masking.compute_epi_mask(fmri_img)
masked_data = masking.apply_mask(fmri_img, brain_mask)

# Save preprocessed data
np.save('subject_001_preprocessed.npy', masked_data)

EEG Data Preprocessing Example

import mne

# Load EEG data
raw = mne.io.read_raw_fif('subject_001_raw.fif')

# Filter
raw.filter(l_freq=1.0, h_freq=40.0)

# Remove artifacts (ICA)
ica = mne.preprocessing.ICA(n_components=20)
ica.fit(raw)
ica.exclude = [0, 1]  # Identified artifact components
raw_clean = ica.apply(raw)

# Save
raw_clean.save('subject_001_clean.fif')

Check GPU Availability

import torch

# Check CUDA availability
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"GPU count: {torch.cuda.device_count()}")
print(f"Current GPU: {torch.cuda.current_device()}")
print(f"GPU name: {torch.cuda.get_device_name(0)}")

Basic Training Loop with GPU

# Move model and data to GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = YourModel().to(device)

# Training loop
for epoch in range(num_epochs):
    for batch_data, batch_labels in dataloader:
        batch_data = batch_data.to(device)
        batch_labels = batch_labels.to(device)

        outputs = model(batch_data)
        loss = criterion(outputs, batch_labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

For teams working with very large models (e.g., ABCD dataset with 26TB):

import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel

# Initialize process group
dist.init_process_group(backend='nccl')

# Wrap model with DDP
model = YourLargeModel()
model = DistributedDataParallel(model)

# Training continues as usual
# The framework handles gradient synchronization

Consult with GPU programming mentors on-site for optimization!

Day 1: Setup & First Results

• ✅ Environment setup complete (should take < 1 hour)
• ✅ Data loading verified
• ✅ Baseline model running
• ✅ Goal: Get first training run completed

Day 2: Optimization & Iteration

• ✅ Analyze initial results
• ✅ Implement improvements
• ✅ Cross-team knowledge sharing
• ✅ Goal: Achieve promising preliminary results

Day 3: Refinement & Validation

• ✅ Finalize best model
• ✅ Run comprehensive validation
• ✅ Prepare visualizations
• ✅ Goal: Complete training and validation

Day 4: Presentation & Documentation

• ✅ Create presentation slides
• ✅ Document code and results
• ✅ Practice presentation
• ✅ Celebrate your achievement!

Q: What if I don’t have experience with GPU programming? A: That’s okay! We have GPU programming mentors available. Focus on getting your data and model ready, and they’ll help with optimization.

Q: Can I bring my own hardware? A: Yes, but we also provide access to GPU servers. Test your hardware beforehand to ensure it’s sufficient.

Q: What if our data doesn’t arrive in time? A: This is why early preparation is critical! Have a backup dataset ready, or coordinate with other teams for data sharing.

Q: How much sleep should we plan for? A: Manage your energy wisely. Sleep deprivation leads to bugs and poor decisions. Aim for at least 4-5 hours per night.