OSCR

Neural selectivity for social interactions in the infant brain.

Code ↔ Paper

2 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 2 matches
  1. [1] § STAR★Methods › Quantification and statistical analysis › Preprocessing of fNIRS data ↔ Data and code/fNIRS_analyses_shared.py, lines 109–185 · score 0.96 · Beer Lambert law, band passed filtered, signal enhancement, negative correlation, MNE NIRS, preprocessing
  2. [2] § STAR★Methods › Quantification and statistical analysis › Analyses ↔ Data and code/fNIRS_analyses_shared.py, lines 596–610 · score 0.60 · 0–14 sec, HbO, channel, interacting

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 875 lines · 38 KB · no license · 2 matches

  1. # -*- coding: utf-8 -*-
  2. """
  3. fNIRS analyses for "Neural selectivity for social interactions in the infant brain"
  5. Analysis script for the infant study (Experiment 2). Analyses for adult data is identical,
  6. except for small preprocessing dissimilarities, indicated in the manuscript.
  8. @author: mmello
  9. """
  11. #%% Import libraries and define functions
  12. import os
  13. import os.path as op
  14. os.environ['R_HOME'] = '...' # your path to R
  16. # General-purpose packages
  17. import matplotlib.pyplot as plt
  18. import pandas as pd
  19. import scipy
  20. import numpy as np
  21. import matplotlib as mpl
  22. from matplotlib.colors import LinearSegmentedColormap
  23. from itertools import compress
  24. import collections
  25. from copy import deepcopy
  26. from scipy.stats import sem, norm
  27. from scipy.signal import find_peaks
  28. from scipy.spatial.distance import pdist, squareform
  29. from scipy.sparse import csr_matrix
  30. import pywt
  31. from pymer4.models import Lmer
  33. # MNE packages
  34. import mne
  35. import mne_nirs
  36. from mne.stats import permutation_cluster_1samp_test
  38. # The following two imports are used to download necessary files to plot data on adult and infant brain templates
  39. # from mne.datasets import fetch_infant_template
  40. # from mne.datasets import fetch_fsaverage
  43. # Define the wavelet-based filtering function
  44. def wavelet_based_filtering(signal, wavelet='db5', level=None, alpha=5):
  45. coeffs = pywt.wavedec(signal, wavelet, level=level)
  46. for i in range(1, len(coeffs)):
  47. detail_coeffs = coeffs[i]
  48. q1 = np.percentile(detail_coeffs, 25)
  49. q3 = np.percentile(detail_coeffs, 75)
  50. iqr = q3 - q1
  51. lower_bound = q1 - alpha * iqr
  52. upper_bound = q3 + alpha * iqr
  53. coeffs[i] = np.where((detail_coeffs < lower_bound) | (detail_coeffs > upper_bound), 0, detail_coeffs)
  54. filtered_signal = pywt.waverec(coeffs, wavelet)
  56. # Ensure the filtered signal has the same length as the original signal
  57. if len(filtered_signal) != len(signal):
  58. filtered_signal = filtered_signal[:len(signal)] # Trim to the original length
  60. return filtered_signal
  64. #%% Define individual-level analyses
  66. data_dir = "C:/Users/mmello/Desktop/fNIRS babies/DATA/together/"
  68. def facingness_waveform(subj_path, ID):
  70. raw = mne.io.read_raw_nirx(subj_path, verbose=True, preload=True)
  72. raw.info["subject_info"]
  73. raw.get_data().shape
  75. ## Plot raw data
  76. # mne.viz.plot_sensors(raw.info, kind='topomap', show_names=True)
  77. # raw.plot(duration=20000, show_scrollbars=False, n_channels=len(raw.ch_names))
  79. ## Define triggers
  80. raw.annotations.set_durations({'1.0': 10, '2.0': 10, '3.0': 10,
  81. })
  82. raw.annotations.rename({'1.0': 'Interacting', '2.0': 'NonInteracting', '3.0': 'Single',
  83. })
  85. ## Convert to optical density (OD)
  86. raw_od = mne.preprocessing.nirs.optical_density(raw)
  87. # Plot OD data
  88. # raw_od.plot(n_channels=len(raw_od.ch_names), duration=15000, show_scrollbars=False)
  90. ## Find bad channels and interpolate (plotting is commented out)
  91. sci = mne.preprocessing.nirs.scalp_coupling_index(raw_od) #h_freq=1.35, h"_trans_bandwidth=0.1
  92. # fig, ax = plt.subplots()
  93. # ax.hist(sci)
  94. # ax.set(xlabel='Scalp Coupling Index', ylabel='Count', xlim=[0, 1])
  95. raw_od.info["bads"] = list(compress(raw_od.ch_names, sci < 0.7))
  96. print(raw_od.info["bads"])
  97. raw_od.interpolate_bads()
  99. ## Clean data with TDDR
  100. raw_od = mne.preprocessing.nirs.temporal_derivative_distribution_repair(raw_od)
  102. ## Wavelet-based filtering
  103. # Extract data and times from optical density
  104. data_h, times = raw_od.get_data(return_times=True)
  105. # Apply wavelet-based filtering to each channel
  106. filtered_data_wavelet = np.array([wavelet_based_filtering(channel) for channel in data_h])
  107. raw_od._data = filtered_data_wavelet
  109. ## Convert to haemoglobin concentration data and band-pass filter
  110. raw_haemo_b = mne.preprocessing.nirs.beer_lambert_law(raw_od, ppf=0.5)
  111. raw_haemo_b = raw_haemo_b.filter(0.01, 0.2, h_trans_bandwidth=0.2, l_trans_bandwidth=0.01, verbose=False)
  113. ## Negative correlation enhancement for systemic noise removal
  114. raw_haemo_b = mne_nirs.signal_enhancement.enhance_negative_correlation(raw_haemo_b)
  116. ## Plot cleaned haemodynamic data
  117. # raw_haemo_b.plot(n_channels=len(raw_haemo_b.ch_names), duration=20000, show_scrollbars=False)
  120. ## Extracting epochs (and plot events)
  121. events, event_dict = mne.events_from_annotations(raw_haemo_b, regexp='(Interacting|NonInteracting|Single)')
  122. # mne.viz.plot_events(events, event_id=event_dict,
  123. # sfreq=raw_haemo_b.info['sfreq'])
  125. epochs = mne.Epochs(raw_haemo_b, events, event_id=event_dict, tmin=-2, tmax=16,
  126. verbose=False, preload=True,
  127. baseline=(-2, 0),
  128. )
  131. ## Removing trials based on video recordings (6-mo)
  132. if ID == 'SUB02 - 6mo':
  133. indices_to_remove = [19, 22, 24, 27, 28, 30]
  134. epochs.drop(indices_to_remove)
  135. elif ID == 'SUB03 - 6mo':
  136. indices_to_remove = [33, 36]
  137. epochs.drop(indices_to_remove)
  138. elif ID == 'SUB04 - 6mo':
  139. indices_to_remove = [13, 15, 19, 22, 23, 24]
  140. epochs.drop(indices_to_remove)
  141. elif ID == 'SUB05 - 6mo':
  142. indices_to_remove = [18, 19]
  143. epochs.drop(indices_to_remove)
  144. elif ID == 'SUB06 - 6mo':
  145. indices_to_remove = [34, 37, 38]
  146. epochs.drop(indices_to_remove)
  147. elif ID == 'SUB07 - 6mo':
  148. indices_to_remove = [27, 41, 43, 44, 46, 47]
  149. epochs.drop(indices_to_remove)
  150. elif ID == 'SUB08 - 6mo':
  151. indices_to_remove = [21]
  152. epochs.drop(indices_to_remove)
  153. elif ID == 'SUB09 - 6mo':
  154. indices_to_remove = [12, 18, 19, 22, 23, 24, 26, 27]
  155. epochs.drop(indices_to_remove)
  156. elif ID == 'SUB11 - 6mo':
  157. indices_to_remove = [35, 42]
  158. epochs.drop(indices_to_remove)
  159. elif ID == 'SUB12 - 6mo':
  160. indices_to_remove = [19, 20, 22, 23, 25]
  161. epochs.drop(indices_to_remove)
  162. elif ID == 'SUB13 - 6mo':
  163. indices_to_remove = [16, 17, 19, 21, 22, 27]
  164. epochs.drop(indices_to_remove)
  165. elif ID == 'SUB14 - 6mo':
  166. indices_to_remove = [10, 16, 17, 18, 19]
  167. epochs.drop(indices_to_remove)
  168. elif ID == 'SUB15 - 6mo':
  169. indices_to_remove = [12, 13, 17, 21, 28]
  170. epochs.drop(indices_to_remove)
  171. elif ID == 'SUB16 - 6mo':
  172. indices_to_remove = [15, 17, 20, 25, 27, 28]
  173. epochs.drop(indices_to_remove)
  174. elif ID == 'SUB17 - 6mo':
  175. indices_to_remove = [29]
  176. epochs.drop(indices_to_remove)
  177. elif ID == 'SUB18 - 6mo':
  178. indices_to_remove = [3, 10, 13, 17, 18, 21, 24, 30, 32, 33, 34]
  179. epochs.drop(indices_to_remove)
  180. elif ID == 'SUB19 - 6mo':
  181. indices_to_remove = [17, 18, 19, 26]
  182. epochs.drop(indices_to_remove)
  183. elif ID == 'SUB21 - 6mo':
  184. indices_to_remove = [9, 10, 11, 12, 13, 14, 15, 18, 21, 22]
  185. epochs.drop(indices_to_remove)
  187. ## Removing trials based on video recordings (10-mo)
  188. if ID == 'SUB02 - 10mo':
  189. indices_to_remove = [14, 17, 21]
  190. epochs.drop(indices_to_remove)
  191. elif ID == 'SUB03 - 10mo':
  192. indices_to_remove = [15, 16, 17]
  193. epochs.drop(indices_to_remove)
  194. elif ID == 'SUB04 - 10mo':
  195. indices_to_remove = [5, 11, 12, 13, 18, 21, 23, 24, 25]
  196. epochs.drop(indices_to_remove)
  197. elif ID == 'SUB05 - 10mo':
  198. indices_to_remove = [25, 32, 34, 46]
  199. epochs.drop(indices_to_remove)
  200. elif ID == 'SUB06 - 10mo':
  201. indices_to_remove = [16, 29, 31, 34, 41, 42]
  202. epochs.drop(indices_to_remove)
  203. elif ID == 'SUB07 - 10mo':
  204. indices_to_remove = [24]
  205. epochs.drop(indices_to_remove)
  206. elif ID == 'SUB08 - 10mo':
  207. indices_to_remove = []
  208. epochs.drop(indices_to_remove)
  209. elif ID == 'SUB09 - 10mo':
  210. indices_to_remove = [23, 24, 29, 31, 33, 34, 38]
  211. epochs.drop(indices_to_remove)
  212. elif ID == 'SUB10 - 10mo':
  213. indices_to_remove = [9, 11, 22, 23, 38]
  214. epochs.drop(indices_to_remove)
  215. elif ID == 'SUB11 - 10mo':
  216. indices_to_remove = [5, 6, 7, 8, 9, 11, 12, 13, 14, 18, 21, 27, 28, 30, 31, 32, 34]
  217. epochs.drop(indices_to_remove)
  218. elif ID == 'SUB12 - 10mo':
  219. indices_to_remove = [20, 21]
  220. epochs.drop(indices_to_remove)
  221. elif ID == 'SUB13 - 10mo':
  222. indices_to_remove = [6, 7, 8, 12, 15, 18, 19, 20, 21, 23]
  223. epochs.drop(indices_to_remove)
  224. elif ID == 'SUB14 - 10mo':
  225. indices_to_remove = [8, 10, 17, 31, 33, 34]
  226. epochs.drop(indices_to_remove)
  227. elif ID == 'SUB15 - 10mo':
  228. indices_to_remove = [8, 9, 17]
  229. epochs.drop(indices_to_remove)
  230. elif ID == 'SUB16 - 10mo':
  231. indices_to_remove = [14, 18, 24, 25]
  232. epochs.drop(indices_to_remove)
  233. elif ID == 'SUB17 - 10mo':
  234. indices_to_remove = [29, 33, 35]
  235. epochs.drop(indices_to_remove)
  236. elif ID == 'SUB18 - 10mo':
  237. indices_to_remove = [13, 14, 20, 21, 23, 28, 30]
  238. epochs.drop(indices_to_remove)
  239. elif ID == 'SUB19 - 10mo':
  240. indices_to_remove = [25, 27, 31, 32]
  241. epochs.drop(indices_to_remove)
  242. elif ID == 'SUB20 - 10mo':
  243. indices_to_remove = [8, 11, 12, 14, 15, 19, 21, 24, 25]
  244. epochs.drop(indices_to_remove)
  245. elif ID == 'SUB21 - 10mo':
  246. indices_to_remove = [12, 17, 20]
  247. epochs.drop(indices_to_remove)
  249. print(len(epochs)) #print number of remaining trials
  251. # Create dictionaries of HbO/HbR responses
  252. evoked_dict = {'Facing/HbO': epochs['Interacting'].average(picks='hbo'),
  253. 'Facing/HbR': epochs['Interacting'].average(picks='hbr'),
  254. 'Away/HbO': epochs['NonInteracting'].average(picks='hbo'),
  255. 'Away/HbR': epochs['NonInteracting'].average(picks='hbr'),
  256. 'Single/HbO': epochs['Single'].average(picks='hbo'),
  257. 'Single/HbR': epochs['Single'].average(picks='hbr')}
  259. ## Rename channels until the encoding of frequency in ch_name is fixed
  260. for condition in evoked_dict:
  261. evoked_dict[condition].rename_channels(lambda x: x[:-4])
  264. ## Store individual data for group-level analysis
  265. return raw, raw_haemo_b, epochs
  268. #%% Individual-level analysis
  270. ## Load data
  271. # Separate dictionaries for each group
  272. all_evokeds_6mo = collections.defaultdict(list)
  273. all_evokeds_10mo = collections.defaultdict(list)
  275. for root, dirs, files in os.walk(os.path.normpath(data_dir), topdown=False):
  276. for subj in dirs:
  277. if 'sync' not in subj and 'bad' not in subj:
  278. print("Now processing subject: " + subj)
  280. subj_path = os.path.join(data_dir, subj)
  282. # Run your individual analysis
  283. raw, raw_haemo_b, epochs = facingness_waveform(subj_path, subj)
  285. # Save data into the appropriate dictionary
  286. if "6mo" in subj:
  287. for condition in epochs.event_id:
  288. all_evokeds_6mo[condition].append(epochs[condition].average())
  289. elif "10mo" in subj:
  290. for condition in epochs.event_id:
  291. all_evokeds_10mo[condition].append(epochs[condition].average())
  294. #%% Visualize channel montage in infants
  296. subjects_dir = op.join(mne.datasets.sample.data_path(), "subjects")
  299. ##6-months
  300. trans = mne.read_trans("C:/Users/mmello/mne_data/MNE-sample-data/subjects/ANTS6-0Months3T/bem/fsaverage-trans.fif")
  301. brain = mne.viz.Brain(
  302. "ANTS6-0Months3T", subjects_dir=subjects_dir, background="w", cortex="0.5"
  303. )
  304. brain.add_sensors(
  305. raw_haemo_b.info, trans=trans, fnirs=["channels", "pairs", "sources", "detectors"]
  306. )
  307. brain.show_view(azimuth=180, elevation=80, distance=250)
  310. ## 10-months
  311. trans = mne.read_trans("C:/Users/mmello/mne_data/MNE-sample-data/subjects/ANTS10-5Months3T/bem/fsaverage-trans.fif")
  312. brain = mne.viz.Brain(
  313. "ANTS10-5Months3T", subjects_dir=subjects_dir, background="w", cortex="0.5"
  314. )
  315. brain.add_sensors(
  316. raw_haemo_b.info, trans=trans, fnirs=["channels", "pairs", "sources", "detectors"]
  317. )
  318. brain.show_view(azimuth=180, elevation=80, distance=250)
  321. #%% Peak detection
  323. # Merge into one dict: all babies (6mo + 10mo)
  324. all_evokeds = collections.defaultdict(list)
  325. # Add 6mo data
  326. for condition, evokeds in all_evokeds_6mo.items():
  327. all_evokeds[condition].extend(evokeds)
  328. # Add 10mo data
  329. for condition, evokeds in all_evokeds_10mo.items():
  330. all_evokeds[condition].extend(evokeds)
  333. # Stack data from all evoked responses for Facing and Away
  334. evokeds_facing = all_evokeds['Interacting']
  335. evokeds_away = all_evokeds['NonInteracting']
  337. # Concatenate both conditions
  338. evokeds_combined = evokeds_facing + evokeds_away
  340. # Build array: (n_subjects_total, n_channels, n_times)
  341. data_array = np.array([evoked._data for evoked in evokeds_combined])
  343. # Average across channels for each subject
  344. data_avg_channels = data_array.mean(axis=1)
  346. # Compute grand average and standard error
  347. grand_avg = data_avg_channels.mean(axis=0)
  348. conf_interval = sem(data_avg_channels, axis=0)
  350. # Get time axis from one of the evoked objects
  351. times = evokeds_combined[0].times
  353. # Find peaks in the grand average
  354. peaks_avg, _ = find_peaks(grand_avg, height=0)
  356. # Keep only the first peak (if any)
  357. if len(peaks_avg) > 0:
  358. first_peak = peaks_avg[0]
  359. else:
  360. first_peak = None
  362. # Plot
  363. plt.figure(figsize=(10, 5))
  364. plt.plot(times, grand_avg, color='red', label='Mean across all channels')
  365. plt.fill_between(times, grand_avg - conf_interval, grand_avg + conf_interval,
  366. color='red', alpha=0.3, label='95% CI')
  368. # Plot only the first peak marker
  369. if first_peak is not None:
  370. plt.plot(times[first_peak], grand_avg[first_peak], "x", color='black', label='Peak')
  372. plt.xlabel('Time (s)')
  373. plt.ylabel('Amplitude')
  374. plt.title('Grand Average Across All Channels - Interacting + Non-interacting')
  375. plt.xlim(-2.5,15)
  376. plt.ylim(-3.5*1e-7,3.5*1e-7)
  377. plt.legend(loc='lower center')
  378. plt.grid(True)
  379. plt.tight_layout()
  380. plt.show()
  382. # Print first peak time
  383. if first_peak is not None:
  384. print('First peak time (s):', times[first_peak])
  385. else:
  386. print('No peaks found.')
  389. #%% Group-level analyses - Visualization
  391. # Plot average waveform
  392. fig, axes = plt.subplots(nrows=1, ncols=len(all_evokeds), figsize=(17, 5))
  393. lims = dict(hbo=[-3, 3], hbr=[-3, 3])
  395. #
  396. for (pick, color) in zip(['hbo', 'hbr'], ['r', 'b']):
  397. for idx, (evoked_name, evoked_data) in enumerate(all_evokeds.items()):
  398. mne.viz.plot_compare_evokeds(
  399. {evoked_name: evoked_data}, combine='mean',
  400. picks=pick, axes=axes[idx], show=False, ylim=lims,
  401. colors=[color], legend=False, ci=0.95,
  402. show_sensors=idx == 1
  403. )
  404. axes[idx].set_title('{}'.format(evoked_name))
  405. if idx == 0: # Set y-axis label for the first subplot
  406. axes[idx].set_ylabel('Haemoglobin concentration (μM)')
  407. # Remove grid for the current subplot
  408. axes[idx].grid(False)
  411. # Plot topomap for each condition
  412. times = np.arange(2, 16, 5.0)
  413. avg_evoked_facing = mne.grand_average(all_evokeds['Interacting'])
  414. avg_evoked_away = mne.grand_average(all_evokeds['NonInteracting'])
  415. avg_evoked_facing.plot_topomap(times=times, cmap=mpl.cm.coolwarm, extrapolate='local',
  416. sphere='auto', vlim=(-3, 3), image_interp='linear')
  417. avg_evoked_away.plot_topomap(times=times, cmap=mpl.cm.coolwarm, extrapolate='local',
  418. sphere='auto', vlim=(-3, 3), image_interp='linear')
  419. plt.show()
  421. ## Plot topomap for each Interacting - NonInteracting
  422. avg_evoked_con = avg_evoked_facing._data - avg_evoked_away._data
  423. info = avg_evoked_facing.info
  424. # Create a new Evoked object
  425. evoked_con = mne.EvokedArray(avg_evoked_con, info, tmin=avg_evoked_facing.times[0])
  426. evoked_con.plot_topomap(times=times, cmap=mpl.cm.coolwarm, extrapolate='local',
  427. sphere='auto', vlim=(-3, 3), image_interp='linear')
  428. plt.show()
  431. #%% Group-level analyses - Channel-wise analysis
  433. ## Create dataframes with by participant, by channel, by condition average response
  435. df_babies_6 = pd.DataFrame(columns=['ID', 'Channel', 'Chroma', 'Condition', 'MeanValue'])
  436. # Loop through the conditions (evoked)
  437. for idx, evoked in enumerate(all_evokeds_6mo):
  438. subj_id = 0 # Initialize subject ID counter
  439. # Loop through each subject's data within the current evoked condition
  440. for subj_data in all_evokeds_6mo[evoked]:
  441. subj_id += 1 # Increment subject ID
  442. # Iterate over the chroma types (e.g., hbo and hbr)
  443. for chroma in ["hbo"]:
  444. # Pick the data corresponding to the current chroma type
  445. data = deepcopy(subj_data).pick(chroma)
  446. # Crop the data to the specified time range and scale
  447. cropped_data = data.crop(tmin=0, tmax=14).data * 1.0e6
  448. # Compute the mean value for each channel
  449. mean_values = cropped_data.mean(axis=1) # Mean across time points for each channel
  450. # Iterate over each channel and append the mean value to the all_ROIs DataFrame
  451. for channel_idx, mean_value in enumerate(mean_values):
  452. this_df = pd.DataFrame(
  453. {'ID': subj_id, 'Channel': channel_idx, 'Chroma': chroma,
  454. 'Condition': evoked, 'MeanValue': mean_value}, index=[0])
  455. df_babies_6 = pd.concat([df_babies_6, this_df], ignore_index=True)
  456. # Print a message when done processing data for the current subject
  457. print(f"Finished processing data for Subject ID: {subj_id}")
  458. # Print a message when done processing data for the last subject of the current condition
  459. print(f"Finished processing data for all subjects in Condition: {evoked}")
  462. df_babies_10 = pd.DataFrame(columns=['ID', 'Channel', 'Chroma', 'Condition', 'MeanValue'])
  463. # Loop through the conditions (evoked)
  464. for idx, evoked in enumerate(all_evokeds_10mo):
  465. subj_id = 0 # Initialize subject ID counter
  466. # Loop through each subject's data within the current evoked condition
  467. for subj_data in all_evokeds_10mo[evoked]:
  468. subj_id += 1 # Increment subject ID
  469. # Iterate over the chroma types (e.g., hbo and hbr)
  470. for chroma in ["hbo"]:
  471. # Pick the data corresponding to the current chroma type
  472. data = deepcopy(subj_data).pick(chroma)
  473. # Crop the data to the specified time range and scale
  474. cropped_data = data.crop(tmin=0, tmax=14).data * 1.0e6
  475. # Compute the mean value for each channel
  476. mean_values = cropped_data.mean(axis=1) # Mean across time points for each channel
  477. # Iterate over each channel and append the mean value to the all_ROIs DataFrame
  478. for channel_idx, mean_value in enumerate(mean_values):
  479. this_df = pd.DataFrame(
  480. {'ID': subj_id, 'Channel': channel_idx, 'Chroma': chroma,
  481. 'Condition': evoked, 'MeanValue': mean_value}, index=[0])
  482. df_babies_10 = pd.concat([df_babies_10, this_df], ignore_index=True)
  483. # Print a message when done processing data for the current subject
  484. print(f"Finished processing data for Subject ID: {subj_id}")
  485. # Print a message when done processing data for the last subject of the current condition
  486. print(f"Finished processing data for all subjects in Condition: {evoked}")
  488. # Replace channel indices with their original names
  489. hbo_channels = [ch for ch in raw_haemo_b.info['ch_names'] if 'hbo' in ch.lower()]
  490. channel_mapping = {i: name for i, name in enumerate(hbo_channels)}
  492. df_babies_6['ch_name'] = df_babies_6['Channel'].replace(channel_mapping)
  493. df_babies_10['ch_name'] = df_babies_10['Channel'].replace(channel_mapping)
  496. ## Compute contrast (Interacting - NonInteracting) for 10-month-olds
  497. difference_df_6 = df_babies_6.pivot_table(
  498. index=['ID', 'ch_name', 'Chroma'],
  499. columns='Condition',
  500. values='MeanValue')
  501. difference_df_6['Difference'] = difference_df_6['Interacting'] - difference_df_6['NonInteracting']
  502. difference_df_6 = difference_df_6.reset_index()
  503. print(difference_df_6)
  505. ## Compute contrast (Interacting - NonInteracting) for 10-month-olds
  506. difference_df_10 = df_babies_10.pivot_table(
  507. index=['ID', 'ch_name', 'Chroma'],
  508. columns='Condition',
  509. values='MeanValue')
  510. difference_df_10['Difference'] = difference_df_10['Interacting'] - difference_df_10['NonInteracting']
  511. difference_df_10 = difference_df_10.reset_index()
  512. print(difference_df_6)
  514. difference_df_6['age'] = '6mo'
  515. difference_df_10['age'] = '10mo'
  516. df_concat = pd.concat([difference_df_10, difference_df_6], ignore_index=True)
  519. df_concat['age_contrast'] = df_concat['age'].map({'10mo': 0.5, '6mo': -0.5})
  521. ## Run channel-wise analysis on both infant groups
  522. model = Lmer('Difference ~ -1 + ch_name*age_contrast + (1|ID)', data=df_concat)
  523. model_results = model.fit()
  524. model.anova() # Effect of channel, bu no effect of age, nor interaction
  525. print(model_results) # Print model estimates (by-channel coefficients)
  528. ## Visualization of results on brain template (10month-old brain)
  530. # Necassary steps to adapt output to MNE visualization function (_plot_GLM_surface_projection)
  531. # Note that we are using this function flexibily to plot HbO concentration
  532. model_results = model_results.rename(columns={'Estimate': 'Coef.'})
  533. model_results['ch_name'] = model_results.index.str.replace('ch_name', '', regex=False)
  535. # Define the desired order for 'ch_name'
  536. desired_order = [
  537. 'S1_D1 hbo', 'S1_D2 hbo', 'S1_D9 hbo', 'S2_D1 hbo', 'S2_D2 hbo', 'S2_D3 hbo',
  538. 'S3_D3 hbo', 'S4_D2 hbo', 'S4_D4 hbo', 'S4_D5 hbo', 'S5_D3 hbo', 'S5_D4 hbo',
  539. 'S5_D6 hbo', 'S6_D4 hbo', 'S6_D5 hbo', 'S6_D6 hbo', 'S6_D7 hbo', 'S7_D6 hbo',
  540. 'S8_D6 hbo', 'S8_D7 hbo', 'S8_D8 hbo', 'S9_D1 hbo', 'S9_D9 hbo', 'S9_D10 hbo',
  541. 'S10_D10 hbo', 'S11_D10 hbo', 'S11_D11 hbo', 'S11_D12 hbo', 'S12_D9 hbo',
  542. 'S12_D11 hbo', 'S12_D13 hbo', 'S13_D11 hbo', 'S13_D12 hbo', 'S13_D13 hbo',
  543. 'S13_D14 hbo', 'S14_D12 hbo', 'S15_D12 hbo', 'S15_D14 hbo', 'S15_D15 hbo'
  544. ]
  545. # Reorder the DataFrame based on the 'ch_name' column according to the desired order
  546. model_results['ch_name'] = pd.Categorical(model_results['ch_name'], categories=desired_order, ordered=True)
  547. # Sort the DataFrame based on the new 'ch_name' order
  548. model_results = model_results.sort_values('ch_name')
  549. # # To view the model summary
  550. model_results = model_results.head(39) # Restrict the output to the channel coefficients (main effect)
  551. print(model_results) # Print again
  554. ## Plot the results!
  555. # Note that, in order to successfully plot with this function, internal options of the function itself need to be updated...
  556. # ... to show an infant brain (and not the adult one, which is default)
  557. # To get help about this, please contact me at [email hidden]
  558. clim = dict(kind='value', pos_lims=(0, 1, 4), neg_lims=(-4, -1, 0))
  559. brain = mne_nirs.visualisation.plot_glm_surface_projection(raw_haemo_b.copy().pick("hbo"),
  560. model_results, clim=clim, view='lateral', mode='weighted', colormap='RdBu_r',
  561. colorbar=False, size=(800, 700), value='T-stat', distance=0.015)
  563. # Plot only significant channels: t-value >= |1.96|
  564. significant_results_inter = model_results.copy()
  565. # # Set values to 0 where p-value is >= 0.05
  566. significant_results_inter.loc[significant_results_inter['P-val'] > 0.051, 'T-stat'] = 0 # Ensure correct column name
  567. # clim = dict(kind='value', pos_lims=(0, 1, 4), neg_lims=(-4, -1, 0))
  568. brain = mne_nirs.visualisation.plot_glm_surface_projection(raw_haemo_b.copy().pick("hbo"),
  569. significant_results_inter, clim=clim, view='lateral', colormap='RdBu_r',
  570. colorbar=False, size=(800, 700), value='T-stat', distance=0.015)
  574. ## Separate analyses for each group. Plot the same way
  575. ## 6-month-olds
  576. model = Lmer('Difference ~ -1 + ch_name + (1|ID)', data=difference_df_6)
  577. model_results = model.fit()
  578. print(model_results)
  580. ## 10-month-olds
  581. model = Lmer('Difference ~ -1 + ch_name + (1|ID)', data=difference_df_10)
  582. model_results = model.fit()
  583. print(model_results)
  587. #%% Group-level analyses - Cluster-based analysis
  589. ## The following is on both infant groups together.
  590. ## You can compare the two groups with the function 'permutation_cluster_test'
  592. # Function to ensure only HbO channels are picked
  593. def get_hbo_channels(evoked):
  594. hbo_picks = mne.pick_types(evoked.info, fnirs='hbo')
  595. return hbo_picks
  596. # Initialize lists for HbO evoked responses
  597. evoked_hbo_facing = []
  598. evoked_hbo_away = []
  599. # Loop through each evoked response in 'Facing' and 'Away' conditions
  600. for i in range(len(all_evokeds['Interacting'])):
  601. hbo_picks_facing = get_hbo_channels(all_evokeds['Interacting'][i])
  602. hbo_picks_away = get_hbo_channels(all_evokeds['NonInteracting'][i])
  603. for i in range(len(all_evokeds['Interacting'])):
  604. evoked_f = all_evokeds['Interacting'][i].copy().pick(mne.pick_types(all_evokeds['Interacting'][i].info, fnirs='hbo'))
  605. evoked_a = all_evokeds['NonInteracting'][i].copy().pick(mne.pick_types(all_evokeds['NonInteracting'][i].info, fnirs='hbo'))
  606. # Crop by time (0 to 14 seconds)
  607. evoked_f.crop(tmin=0, tmax=14)
  608. evoked_a.crop(tmin=0, tmax=14)
  609. evoked_hbo_facing.append(evoked_f)
  610. evoked_hbo_away.append(evoked_a)
  613. ## Extract average response for both infant groups together ('all_evokeds' dictionary)
  614. df_babies = pd.DataFrame(columns=['ID', 'Channel', 'Chroma', 'Condition', 'MeanValue'])
  615. # Loop through the conditions (evoked)
  616. for idx, evoked in enumerate(all_evokeds):
  617. subj_id = 0 # Initialize subject ID counter
  618. # Loop through each subject's data within the current evoked condition
  619. for subj_data in all_evokeds[evoked]:
  620. subj_id += 1 # Increment subject ID
  621. # Iterate over the chroma types (e.g., hbo and hbr)
  622. for chroma in ["hbo"]:
  623. # Pick the data corresponding to the current chroma type
  624. data = deepcopy(subj_data).pick(chroma)
  625. # Crop the data to the specified time range and scale
  626. cropped_data = data.crop(tmin=0, tmax=14).data * 1.0e6
  627. # Compute the mean value for each channel
  628. mean_values = cropped_data.mean(axis=1) # Mean across time points for each channel
  629. # Iterate over each channel and append the mean value to the all_ROIs DataFrame
  630. for channel_idx, mean_value in enumerate(mean_values):
  631. this_df = pd.DataFrame(
  632. {'ID': subj_id, 'Channel': channel_idx, 'Chroma': chroma,
  633. 'Condition': evoked, 'MeanValue': mean_value}, index=[0])
  634. df_babies = pd.concat([df_babies, this_df], ignore_index=True)
  635. # Print a message when done processing data for the current subject
  636. print(f"Finished processing data for Subject ID: {subj_id}")
  637. # Print a message when done processing data for the last subject of the current condition
  638. print(f"Finished processing data for all subjects in Condition: {evoked}")
  640. # Cut down the dataframe just to the conditions we are interested in
  641. df_babies.query("Condition in ['Interacting', 'NonInteracting']")
  643. # Compute contrast of interest to use with the 'permutation_cluster_1samp_test' function
  644. difference_df = df_babies.pivot_table(
  645. index=['ID', 'Channel', 'Chroma'],
  646. columns='Condition',
  647. values='MeanValue'
  648. )
  649. difference_df['Difference'] = difference_df['Interacting'] - difference_df['NonInteracting']
  650. difference_df = difference_df.reset_index()
  651. print(difference_df)
  652. # Pivot the DataFrame
  653. df_pivoted = difference_df.pivot(index='ID', columns='Channel', values='Difference')
  656. ## Calculate cluster-forming thershold
  657. n_observations = 20
  658. pval = 0.1 # arbitrary
  659. df = n_observations - 1 # degrees of freedom for the test
  660. thresh = scipy.stats.t.ppf(1 - pval / 2, df) # two-tailed, t distribution
  662. # Get the sensor locations for HbO channels
  663. ch_locs = np.array([epochs['Interacting'].info['chs'][pick]['loc'][:3] for pick in hbo_picks_facing])
  664. # Compute pairwise distances between sensors
  665. dists = squareform(pdist(ch_locs))
  666. # Define a distance threshold to determine adjacency (e.g., 0.03 meters)
  667. distance_threshold = 0.025
  668. adjacency = dists < distance_threshold
  669. adjacency_2, chs = mne.channels.find_ch_adjacency(evoked_hbo_facing[0].info, ch_type=None)
  670. mne.viz.plot_ch_adjacency(evoked_hbo_facing[0].info, adjacency, chs, kind='2d', edit=False)
  671. # Ensure the adjacency matrix is symmetric and binary
  672. adjacency = adjacency.astype(int)
  673. # Convert adjacency matrix to SciPy sparse matrix
  674. adjacency_sparse = csr_matrix(adjacency)
  675. # Check if the adjacency matrix has the correct size
  676. print(f'Adjacency matrix shape: {adjacency_sparse.shape}')
  677. print(f'Number of channels: {len(hbo_picks_facing)}')
  679. ## Run permutation test
  680. T_obs, clusters, cluster_p_values, H0 = permutation_cluster_1samp_test(
  681. df_pivoted, n_permutations=5000, out_type='indices', tail = 0,
  682. n_jobs=1, threshold=thresh, adjacency=adjacency_sparse)
  684. # Find significant clusters
  685. significant_clusters = np.where(cluster_p_values < 0.05)[0]
  686. # Filter out single-channel clusters
  687. filtered_clusters = []
  688. filtered_p_values = []
  689. for cluster_idx in significant_clusters:
  690. cluster = clusters[cluster_idx]
  691. # Assuming cluster[0] contains channel indices
  692. unique_channels = np.unique(cluster[0])
  693. if len(unique_channels) > 0: # Exclude single-channel clusters
  694. filtered_clusters.append(cluster)
  695. filtered_p_values.append(cluster_p_values[cluster_idx])
  696. # Convert to numpy arrays for easier handling
  697. filtered_clusters = np.array(filtered_clusters, dtype=object)
  698. filtered_p_values = np.array(filtered_p_values)
  699. print(f"\nNumber of significant clusters (excluding single-channel clusters): {len(filtered_clusters)}")
  700. for i, cluster in enumerate(filtered_clusters):
  701. cluster_idx = significant_clusters[i]
  702. print(f"Cluster {cluster_idx}:")
  703. print(f" p-value: {filtered_p_values[i]}")
  704. print(f" Channels involved: {np.unique(cluster[0])}")
  707. # Compute the mean T-values across time for visualization
  708. T_obs_avg = T_obs # Average T-values over the time dimension
  709. for i, cluster in enumerate(filtered_clusters):
  710. significant_chs = np.unique(cluster[0]) # Get unique channel indices from the cluster
  711. # Ensure significant_chs contains valid integer indices
  712. significant_chs = significant_chs.astype(int)
  713. significant_chs = significant_chs[significant_chs < len(T_obs_avg)] # Ensure indices are within bounds
  714. # Create a mask to highlight significant channels
  715. mask = np.zeros_like(T_obs_avg, dtype=bool)
  716. mask[significant_chs] = True # Mask significant channels
  717. # Plot topomap with the mask
  718. info = evoked_hbo_facing[0].info
  719. fig, ax = plt.subplots()
  721. vmin, vmax = -4, 4
  722. im, _ = mne.viz.plot_topomap(T_obs_avg, info, axes=ax, show=False, cmap='RdBu_r',
  723. mask=mask, extrapolate='local', sphere='auto',
  724. image_interp='linear', vlim=(vmin, vmax),
  725. mask_params=dict(marker='o', markerfacecolor='black',
  726. markersize=10))
  727. # Add colorbar
  728. cbar = fig.colorbar(im, ax=ax)
  729. cbar.set_label("T-value") # Label for clarity
  730. ax.set_title(f"Cluster {significant_clusters[i]} (p={filtered_p_values[i]:.3f})")
  731. plt.show()
  734. # Plot all clusters on the same topomap (note that this has the effect of creating a 'fake' red blob)
  735. combined_mask = np.zeros_like(T_obs_avg, dtype=bool)
  736. for cluster in filtered_clusters:
  737. significant_chs = np.unique(cluster[0]) # Get unique channel indices
  738. significant_chs = significant_chs.astype(int)
  739. significant_chs = significant_chs[significant_chs < len(T_obs_avg)]
  740. combined_mask[significant_chs] = True # Mark channels as significant
  742. info = evoked_hbo_facing[0].info
  743. fig, ax = plt.subplots()
  744. # Plot topomap with combined mask
  745. im, _ = mne.viz.plot_topomap(T_obs_avg, info, axes=ax, show=False, cmap='RdBu_r',
  746. mask=combined_mask, extrapolate='local', sphere='auto',
  747. vlim=(vmin, vmax),
  748. mask_params=dict(marker='o', markerfacecolor='black', markersize=10))
  749. # Add colorbar
  750. cbar = fig.colorbar(im, ax=ax)
  751. cbar.set_label("T-value")
  752. plt.show()
  756. #%% Group-level analysis - Conjuction [Interacting > NonInteracting] vs. [Single > baseline]
  758. # == Interacting > NonInteracting
  759. model_results_interacting = model_results.copy()
  760. significant_results_interacting = model_results_interacting.copy()
  761. # # Set values to 0 where p-value is >= 0.05
  762. significant_results_interacting.loc[significant_results_interacting['P-val'] > 0.051, 'T-stat'] = 0 # Ensure correct column name
  763. significant_results_interacting.loc[significant_results_interacting['T-stat'] < 0, 'T-stat'] = 0
  765. # == Single > baseline
  766. df_single = df_babies.query("Condition in ['Single']")
  767. df_single['ch_name'] = df_single['Channel'].replace(channel_mapping) #channel mapping defined earlier
  769. # Run group level model and convert to dataframe
  770. model_single = Lmer('MeanValue ~ -1 + ch_name + (1|ID)', data=df_single)
  771. model_results_single = model_single.fit()
  773. # Rename and sort channel names (defind in previous analyses)
  774. model_results_single['ch_name'] = model_results_single.index.str.replace('ch_name', '', regex=False)
  775. # Reorder the DataFrame based on the 'ch_name' column according to the desired order
  776. model_results_single['ch_name'] = pd.Categorical(model_results_single['ch_name'], categories=desired_order, ordered=True)
  777. # Sort the DataFrame based on the new 'ch_name' order
  778. model_results_single = model_results_single.sort_values('ch_name')
  780. model_results_single['ch_name'] = model_results_single.index.str.replace('ch_name', '', regex=False).str.replace(':ConditionSingle', '', regex=False)
  781. model_results_single['ch_name'] = pd.Categorical(model_results_single['ch_name'], categories=desired_order, ordered=True)
  782. # Sort the DataFrame based on the new 'ch_name' order
  783. model_results_single = model_results_single.sort_values('ch_name')
  784. # To view the model summary
  785. print(model_results_single)
  787. significant_results_single = model_results_single.copy()
  788. # # Set values to 0 where p-value is >= 0.05
  789. significant_results_single.loc[significant_results_single['P-val'] > 0.051, 'T-stat'] = 0 # Ensure correct column name
  790. significant_results_single.loc[significant_results_single['T-stat'] < 0, 'T-stat'] = 0
  793. # == Combine results
  794. combined_result = significant_results_interacting.copy()
  795. significant_results_single.index = significant_results_single.index.str[:16]
  796. significant_results_interacting.index = significant_results_interacting.index.str[:16]
  797. # Now check if they match
  798. print(significant_results_interacting.index.equals(significant_results_single.index)) # Should be True
  800. # A trick to be able to plot the two contrasts on the same brain. Only t-value is relevant in this dataframe
  801. combined_result['T-stat'] = significant_results_interacting['T-stat'] - significant_results_single['T-stat']
  804. ## Plot results with a custom color bar to be able to show significant channels from both contrasts
  805. n_colors_half = 128 # number of colors per half
  806. viridis = plt.get_cmap('PiYG')
  807. rdbu_r = plt.get_cmap('RdBu_r')
  808. # Extract upper half of viridis and reverse it
  809. viridis_upper = viridis(np.linspace(0.5, 1.0, n_colors_half))[::-1]
  810. # Extract upper half of RdBu_r as is
  811. rdbu_r_upper = rdbu_r(np.linspace(0.5, 1.0, n_colors_half))
  812. # Concatenate both halves
  813. combined_colors = np.vstack((viridis_upper, rdbu_r_upper))
  814. # Define vmin/vmax
  815. vmin, vmax = -4, 4
  816. values = np.linspace(vmin, vmax, combined_colors.shape[0])
  817. # Define fading range
  818. fade_halfwidth = 0.6 # adjust for smoother fade
  819. fade_start_neg, fade_end_neg = -1.96 - fade_halfwidth, -1.96 + fade_halfwidth
  820. fade_start_pos, fade_end_pos = 1.96 - fade_halfwidth, 1.96 + fade_halfwidth
  821. # White color
  822. white = np.array([1, 1, 1, 1])
  823. # Apply fading into white
  824. for i, val in enumerate(values):
  825. if -1.96 <= val <= 1.96:
  826. combined_colors[i] = white
  827. elif fade_start_neg < val < fade_end_neg:
  828. t = (val - fade_start_neg) / (fade_end_neg - fade_start_neg)
  829. combined_colors[i] = (1-t) * combined_colors[i] + t * white
  830. elif fade_start_pos < val < fade_end_pos:
  831. t = (val - fade_start_pos) / (fade_end_pos - fade_start_pos)
  832. combined_colors[i] = (1-t) * white + t * combined_colors[i]
  833. # Create custom colormap
  834. custom_cmap = LinearSegmentedColormap.from_list(
  835. "custom_with_white_fading_center", combined_colors
  836. )
  839. ## Plot results!
  840. brain = mne_nirs.visualisation.plot_glm_surface_projection(
  841. raw_haemo_b.copy().pick("hbo"),
  842. combined_result,
  843. clim=clim,
  844. view='lateral',
  845. colormap=custom_cmap,
  846. colorbar=True,
  847. size=(800, 700),
  848. value='T-stat',
  849. distance=0.015
  850. )
  853. ## == Conjunction analysis
  854. # Ensure both have consistent ch_name as index
  855. interacting_df = model_results_interacting.set_index('ch_name')
  856. single_df = model_results_single.set_index('ch_name')
  857. # Select relevant columns (t-statistics)
  858. interacting_t = interacting_df[['T-stat']].rename(columns={'T-stat': 't_interacting'})
  859. single_t = single_df[['T-stat']].rename(columns={'T-stat': 't_single'})
  860. # Merge on ch_name
  861. conj_df = interacting_t.join(single_t, how='inner')
  863. # Compute minimum t-statistics per channel (conjunction)
  864. conj_df['t_min'] = conj_df[['t_interacting', 't_single']].min(axis=1)
  865. # Convert min t-stat to one-sided p-value using standard normal survival function
  866. conj_df['P_conjunction'] = norm.sf(conj_df['t_min']) # sf = 1 - cdf
  867. # Mark significant conjunctions
  868. alpha = 0.05
  869. conj_df['Significant'] = conj_df['P_conjunction'] < alpha
  870. # List channels passing conjunction test
  871. significant_conjunction_channels = conj_df[conj_df['Significant']].index.tolist()
  872. print("Conjunction-significant channels:", significant_conjunction_channels)
  873. # Optional: display summary table
  874. print(conj_df.sort_values('P_conjunction'))

fNIRS_analyses_shared.py, no license · at the source

Overview

Authors: Manuel Mello1, Emilie Serraille1, Jean-Rémy Hochmann1, Liuba Papeo1
ORCID iDs: Manuel Mello
  1. Institut des Sciences Cognitives—Marc Jeannerod, UMR5229, Centre National de La Recherche Scientifique (CNRS) and Université Claude Bernard Lyon 1, 67 Bd. Pinel, 69675 Bron, France
Institutions: Lyon 1 Université (France); Centre National de la Recherche Scientifique (France); Institut des Sciences Cognitives Marc Jeannerod (France)
Journal: iScience, volume 29, issue 6, article 116287
Dates: received 16 October 2025; accepted 21 May 2026; published online 8 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.isci.2026.116287 · PMID 42291211 · PMCID PMC13264107 · OpenAlex W4414426746
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.31234/osf.io/qydmj_v1
Status: code verified
Categories: human (organism), developmental (subfield)
Methods: Spectral & time-frequency, Statistics, Preprocessing, fMRI & imaging
Keywords: health sciences, medicine, neurology, pediatrics, human physiology, natural sciences, biological sciences, neuroscience, developmental neuroscience, cognitive neuroscience
Topic: Child and Animal Learning Development (Developmental and Educational Psychology, Psychology), according to OpenAlex
Funding: ANR-DFG Franco-German (FRAL_RELATIONS_268980); Fondation de France (00134704/WB-2022-46104); fellowship of the LabEx CORTEX of the University of Lyon (ANR-11-LABX-0042)
Citations: not cited yet (Europe PMC); 94 references in the paper
Research resources: R – version 4.3.3 RRID:SCR_001905, MNE Python – version 1.5.0 RRID:SCR_005972, Python – version 3.8.10 RRID:SCR_008394

Abstract

Social cognition develops in the second year of life. Yet even in the first months, infants show sophisticated representation of social interactions. The neural structures supporting these early capacities remain unknown. Here, using functional near-infrared spectroscopy, we show that, like adults, preverbal infants exhibit selective increase in the activity of posterior superior-temporal and temporo-parietal regions when viewing individuals facing and moving toward (vs. away from) each other, as if interacting. No reliable difference emerged between 6- and 10-month-olds, although neural effects were more widespread in the older group, who also showed consistently longer looking times toward interacting dyads. Neural effects of social interactions were spatially distinct from effects of body motion perception, indicating separate mechanisms for perceiving biological agents and interacting agents. The early tuning to visuo-spatial cues of social engagement documented here may orient infants’ attention toward social interactions, thereby facilitating the discovery and learning of human social relationships.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 2 matches between paragraphs and lines of code.

OSF 874rw

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Languages: Python (1)
Size: 12 files, 1 script
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (1 file), MNE-Python (1 file), NumPy (1 file), pandas (1 file), PyWavelets (1 file), SciPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
1 file
At the source: doi.org/10.17605/OSF.IO/874RW

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 1 script, each with its path and the digest of its content;
  • 2 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data and code availability

• Pre-processed fNIRS data and infant looking time data that support the findings of this study are publicly available on the Open Science Framework. https://doi.org/10.17605/OSF.IO/874RW. • The original programming scripts used to pre-process and analyze the data of this study are publicly available on the Open Science Framework. https://doi.org/10.17605/OSF.IO/874RW. • Any additional information required to re-analyze the data reported in this paper are available from the lead contact upon request.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 10 keywords, 3 funders, 87 references, 3 RRIDs.

Cite

This paper

Mello, M., Serraille, E., Hochmann, J.-R., & Papeo, L. (2026). Neural selectivity for social interactions in the infant brain. iScience, 29(6), 116287. https://doi.org/10.1016/j.isci.2026.116287

BibTeX

@article{mello2026neural,
author = {Mello, Manuel and Serraille, Emilie and Hochmann, Jean-Rémy and Papeo, Liuba},
title = {{Neural selectivity for social interactions in the infant brain}},
journal = {iScience},
year = {2026},
month = jun,
volume = {29},
number = {6},
pages = {116287},
publisher = {Elsevier},
issn = {2589-0042},
doi = {10.1016/j.isci.2026.116287},
url = {https://doi.org/10.1016/j.isci.2026.116287},
pmid = {42291211},
pmcid = {PMC13264107}
}

RIS

TY - JOUR
AU - Mello, Manuel
AU - Serraille, Emilie
AU - Hochmann, Jean-Rémy
AU - Papeo, Liuba
TI - Neural selectivity for social interactions in the infant brain
T2 - iScience
J2 - iScience
PY - 2026
DA - 2026/06/08
VL - 29
IS - 6
SP - 116287
SN - 2589-0042
PB - Elsevier
DO - 10.1016/j.isci.2026.116287
UR - https://doi.org/10.1016/j.isci.2026.116287
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.isci.2026.116287",
"type": "article-journal",
"title": "Neural selectivity for social interactions in the infant brain",
"container-title": "iScience",
"author": [
{
"family": "Mello",
"given": "Manuel"
},
{
"family": "Serraille",
"given": "Emilie"
},
{
"family": "Hochmann",
"given": "Jean-Rémy"
},
{
"family": "Papeo",
"given": "Liuba"
}
],
"container-title-short": "iScience",
"volume": "29",
"issue": "6",
"page": "116287",
"DOI": "10.1016/j.isci.2026.116287",
"PMID": "42291211",
"PMCID": "PMC13264107",
"ISSN": "2589-0042",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.isci.2026.116287",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
8
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1016/j.dcn.2026.101765 [code]
Fusiform face area development correlates with development in higher-order social brain regions.
Journal: Developmental cognitive neuroscience
In common: pandas, SciPy, Matplotlib, 1 other tool, 8 references
[2] doi:10.1038/s41467-026-71151-2 [code]
Common and distinct neural correlates of social interaction processing and theory of mind in narratives.
Journal: Nature communications
In common: pandas, SciPy, Matplotlib, 1 other tool, 7 references
[3] doi:10.1016/j.isci.2026.116695 [code]
The naive brain detects face-to-face biological motion.
Journal: iScience
In common: 7 references
[4] doi:10.1162/imag.a.1309 [code]
Probing the content of semantic representations in body-selective regions.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: pandas, SciPy, Matplotlib, 1 other tool, 5 references
[5] doi:10.1162/imag.a.1289 [code]
Measurement prediction and power analysis for fNIRS and DOT.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: MNE-Python, SciPy, Matplotlib, 1 other tool, 5 references
[6] doi:10.1117/1.nph.13.2.025001 [code]
Surface-based image reconstruction optimization for high-density functional near-infrared spectroscopy.
Journal: Neurophotonics
In common: PyWavelets, MNE-Python, pandas, 3 other tools, 2 references
[7] doi:10.1038/s42003-026-09834-1 [code]
Distinct perceptual and conceptual representations of natural actions along the lateral and dorsal visual streams.
Journal: Communications biology
In common: 6 references
[8] doi:10.1038/s41467-026-76098-y [code]
A single computational objective can produce specialization of streams in visual cortex.
Journal: Nature communications
In common: pandas, SciPy, Matplotlib, 1 other tool, 4 references
[9] doi:10.1117/1.nph.13.3.035006 [code]
Characterizing developmental changes in infant habituation using functional change point detection.
Journal: Neurophotonics
In common: pandas, SciPy, Matplotlib, 1 other tool, developmental, 3 references
[10] doi:10.1371/journal.pone.0358044 [code]
An exploratory fNIRS study on directional asymmetry in segmental discrimination: Lateral-rhotic (/la-ra/) and labial-dorsal (/ba-ga/) contrasts tested in 5- and 9-month-old Japanese infants.
Journal: PloS one
In common: pandas, SciPy, Matplotlib, 1 other tool, developmental, 3 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.