neuropixels-analysis

name: neuropixels-analysis description: Analyse de l'enregistrement neural Neuropixels. Chargement de données SpikeGLX/OpenEphys, prétraitement, correction de mouvement, spike sorting Kilosort4, métriques de qualité, curation Allen/IBL, analyse visuelle assistée par IA, pour l'électrophysiologie extracellulaire Neuropixels 1.0/2.0. À utiliser lors du travail avec des enregistrements neuraux, spike sorting, électrophysiologie extracellulaire, ou quand l'utilisateur mentionne Neuropixels, SpikeGLX, Open Ephys, Kilosort, métriques de qualité, ou curation d'unités. license: MIT license tags: [scientific-skills, neuropixels-analysis] metadata: skill-author: K-Dense Inc. ----|-----------|----------|-------| | Neuropixels 1.0 | 960 | 384 | Nécessite correction phase_shift | | Neuropixels 2.0 (single) | 1280 | 384 | Géométrie plus dense | | Neuropixels 2.0 (4-shank) | 5120 | 384 | Enregistrement multi-région |

Démarrage rapide

Import et configuration de base

import spikeinterface.full as si
import neuropixels_analysis as npa

# Configurer le traitement parallèle
job_kwargs = dict(n_jobs=-1, chunk_duration='1s', progress_bar=True)

Chargement de données

# SpikeGLX (le plus courant)
recording = si.read_spikeglx('/path/to/data', stream_id='imec0.ap')

# Open Ephys (courant pour beaucoup de labos)
recording = si.read_openephys('/path/to/Record_Node_101/')

# Vérifier les flux disponibles
streams, ids = si.get_neo_streams('spikeglx', '/path/to/data')
print(streams)  # ['imec0.ap', 'imec0.lf', 'nidq']

# Pour tester avec un sous-ensemble de données
recording = recording.frame_slice(0, int(60 * recording.get_sampling_frequency()))

Pipeline complet (une commande)

# Exécuter le pipeline d'analyse complet
results = npa.run_pipeline(
    recording,
    output_dir='output/',
    sorter='kilosort4',
    curation_method='allen',
)

# Accéder aux résultats
sorting = results['sorting']
metrics = results['metrics']
labels = results['labels']

Workflow d'analyse standard

1. Prétraitement

# Chaîne de prétraitement recommandée
rec = si.highpass_filter(recording, freq_min=400)
rec = si.phase_shift(rec)  # Requis pour Neuropixels 1.0
bad_ids, _ = si.detect_bad_channels(rec)
rec = rec.remove_channels(bad_ids)
rec = si.common_reference(rec, operator='median')

# Ou utiliser notre wrapper
rec = npa.preprocess(recording)

2. Vérifier et corriger la dérive

# Vérifier la dérive (toujours le faire !)
motion_info = npa.estimate_motion(rec, preset='kilosort_like')
npa.plot_drift(rec, motion_info, output='drift_map.png')

# Appliquer la correction si nécessaire
if motion_info['motion'].max() > 10:  # microns
    rec = npa.correct_motion(rec, preset='nonrigid_accurate')

3. Spike Sorting

# Kilosort4 (recommandé, nécessite GPU)
sorting = si.run_sorter('kilosort4', rec, folder='ks4_output')

# Alternatives CPU
sorting = si.run_sorter('tridesclous2', rec, folder='tdc2_output')
sorting = si.run_sorter('spykingcircus2', rec, folder='sc2_output')
sorting = si.run_sorter('mountainsort5', rec, folder='ms5_output')

# Vérifier les sorters disponibles
print(si.installed_sorters())

4. Post-traitement

# Créer un analyseur et calculer toutes les extensions
analyzer = si.create_sorting_analyzer(sorting, rec, sparse=True)

analyzer.compute('random_spikes', max_spikes_per_unit=500)
analyzer.compute('waveforms', ms_before=1.0, ms_after=2.0)
analyzer.compute('templates', operators=['average', 'std'])
analyzer.compute('spike_amplitudes')
analyzer.compute('correlograms', window_ms=50.0, bin_ms=1.0)
analyzer.compute('unit_locations', method='monopolar_triangulation')
analyzer.compute('quality_metrics')

metrics = analyzer.get_extension('quality_metrics').get_data()

5. Curation

# Critères Allen Institute (conservateurs)
good_units = metrics.query("""
    presence_ratio > 0.9 and
    isi_violations_ratio < 0.5 and
    amplitude_cutoff < 0.1
""").index.tolist()

# Ou utiliser la curation automatisée
labels = npa.curate(metrics, method='allen')  # 'allen', 'ibl', 'strict'

6. Curation assistée par IA (pour les unités incertaines)

Lors de l'utilisation de cette skill avec Claude Code, Claude peut directement analyser les tracés de formes d'onde et fournir des décisions de curation expertes. Pour l'accès API programmatique :

from anthropic import Anthropic

# Configurer le client API
client = Anthropic()

# Analyser les unités incertaines visuellement
uncertain = metrics.query('snr > 3 and snr < 8').index.tolist()

for unit_id in uncertain:
    result = npa.analyze_unit_visually(analyzer, unit_id, api_client=client)
    print(f"Unit {unit_id}: {result['classification']}")
    print(f"  Reasoning: {result['reasoning'][:100]}...")

Intégration Claude Code : Lors de l'exécution dans Claude Code, demander à Claude d'examiner directement les tracés de formes d'onde/corrélogrammes - aucune configuration API requise.

7. Générer un rapport d'analyse

# Générer un rapport HTML complet avec visualisations
report_dir = npa.generate_analysis_report(results, 'output/')
# Ouvre report.html avec statistiques récapitulatives, figures et tableau d'unités

# Imprimer un résumé formaté sur la console
npa.print_analysis_summary(results)

8. Exporter les résultats

# Exporter vers Phy pour examen manuel
si.export_to_phy(analyzer, output_folder='phy_export/',
                 compute_pc_features=True, compute_amplitudes=True)

# Exporter vers NWB
from spikeinterface.exporters import export_to_nwb
export_to_nwb(rec, sorting, 'output.nwb')

# Sauvegarder les métriques de qualité
metrics.to_csv('quality_metrics.csv')

Pièges courants et bonnes pratiques

1. Toujours vérifier la dérive avant le spike sorting - dérive > 10μm impacte significativement la qualité
2. Utiliser phase_shift pour les sondes Neuropixels 1.0 (non nécessaire pour 2.0)
3. Sauvegarder les données prétraitées pour éviter les recalculs - utiliser rec.save(folder='preprocessed/')
4. Utiliser GPU pour Kilosort4 - 10 à 50 fois plus rapide que les alternatives CPU
5. Examiner manuellement les unités incertaines - la curation automatisée est un point de départ
6. Combiner les métriques avec l'IA - utiliser les métriques pour les cas clairs, l'IA pour les unités limites
7. Documenter les seuils - différentes analyses peuvent nécessiter des critères différents
8. Exporter vers Phy pour les expériences critiques - la supervision humaine est précieuse

Paramètres clés à ajuster

Prétraitement

• freq_min : Cutoff passe-haut (300-400 Hz typique)
• detect_threshold : Sensibilité de détection de mauvais canaux

Correction de mouvement

• preset : 'kilosort_like' (rapide) ou 'nonrigid_accurate' (meilleur pour dérive sévère)

Spike Sorting (Kilosort4)

• batch_size : Échantillons par lot (30 000 par défaut)
• nblocks : Nombre de blocs de dérive (augmenter pour enregistrements longs)
• Th_learned : Seuil de détection (plus bas = plus de spikes)

Métriques de qualité

• snr_threshold : Cutoff signal-bruit (3-5 typique)
• isi_violations_ratio : Violations réfractaires (0,01-0,5)
• presence_ratio : Couverture d'enregistrement (0,5-0,95)

Ressources incluses

scripts/preprocess_recording.py

Script de prétraitement automatisé :

python scripts/preprocess_recording.py /path/to/data --output preprocessed/

scripts/run_sorting.py

Exécuter le spike sorting :

python scripts/run_sorting.py preprocessed/ --sorter kilosort4 --output sorting/

scripts/compute_metrics.py

Calculer les métriques de qualité et appliquer la curation :

python scripts/compute_metrics.py sorting/ preprocessed/ --output metrics/ --curation allen

scripts/export_to_phy.py

Exporter vers Phy pour curation manuelle :

python scripts/export_to_phy.py metrics/analyzer --output phy_export/

assets/analysis_template.py

Modèle d'analyse complet. Copier et personnaliser :

cp assets/analysis_template.py my_analysis.py
# Modifier les paramètres et exécuter
python my_analysis.py

reference/standard_workflow.md

Workflow détaillé étape par étape avec explications pour chaque stage.

reference/api_reference.md

Référence rapide des fonctions organisée par module.

reference/plotting_guide.md

Guide de visualisation complet pour figures de qualité publication.

Guides de référence détaillés

Installation

# Packages core
pip install spikeinterface[full] probeinterface neo

# Spike sorters
pip install kilosort          # Kilosort4 (GPU requis)
pip install spykingcircus     # SpykingCircus2 (CPU)
pip install mountainsort5     # Mountainsort5 (CPU)

# Notre toolkit
pip install neuropixels-analysis

# Optionnel : curation IA
pip install anthropic

# Optionnel : outils IBL
pip install ibl-neuropixel ibllib

Structure du projet

project/
├── raw_data/
│   └── recording_g0/
│       └── recording_g0_imec0/
│           ├── recording_g0_t0.imec0.ap.bin
│           └── recording_g0_t0.imec0.ap.meta
├── preprocessed/           # Enregistrement prétraité sauvegardé
├── motion/                 # Résultats d'estimation de mouvement
├── sorting_output/         # Sortie du spike sorter
├── analyzer/               # SortingAnalyzer (formes d'onde, métriques)
├── phy_export/             # Pour curation manuelle
├── ai_curation/            # Rapports d'analyse IA
└── results/
    ├── quality_metrics.csv
    ├── curation_labels.json
    └── output.nwb

Ressources supplémentaires

• Documentation SpikeInterface : https://spikeinterface.readthedocs.io/
• Tutoriel Neuropixels : https://spikeinterface.readthedocs.io/en/stable/how_to/analyze_neuropixels.html
• Kilosort4 GitHub : https://github.com/MouseLand/Kilosort
• Outils IBL Neuropixel : https://github.com/int-brain-lab/ibl-neuropixel
• Allen Institute ecephys : https://github.com/AllenInstitute/ecephys_spike_sorting
• Bombcell (QC automatisé) : https://github.com/Julie-Fabre/bombcell
• SpikeAgent (Curation IA) : https://github.com/SpikeAgent/SpikeAgent