OSCR

Attention to speech modulates distortion product otoacoustic emissions evoked by speech-derived stimuli in humans.

Code ↔ Paper

4 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 4 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Materials and methods › Stimuli for eliciting speech-like DPOAEs ↔ stimulus_generation.py, lines 124–148 · score 0.75 · bandpass filter, standard deviations, fundamental waveform, fundamental frequency, signal, Stimuli
  2. [2] § Materials and methods › Stimuli for eliciting speech-like DPOAEs ↔ stimulus_generation.py, lines 150–183 · score 0.70 · Hilbert transform, harmonic overtones, fundamental waveform, Stimuli
  3. [3] § Materials and methods › Analysis of speech-like DPOAEs ↔ DPOAE_analysis.py, lines 664–728 · score 0.66 · imaginary part, complex cross correlation, microphone recording, envelope, waveforms, DPOAEs
  4. [4] § Materials and methods › Analysis of speech-like DPOAEs ↔ cross_correlation.py, the whole file · a weak match · score 0.56 · imaginary part, complex cross correlation, envelope, signal

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 · 661 lines · 30 KB · MIT · 2 matches

  1. import numpy as np
  2. import librosa
  3. from pathlib import Path
  4. import os
  5. import re
  6. import soundfile as sf
  7. import pandas as pd
  8. import scipy.signal as sig
  9. import matplotlib.pyplot as plt
  10. from collections.abc import Iterable
  11. from plot_stimulus_correlations import stimuli_correlation
  12. from butterworth_filter import butter_filter
  14. class stimulus_generator:
  15. """Generates stimuli for speech-DPOAE measurements. Stimuli follow the specified harmonic numbers n1 and n2.
  16. Distortion product is calculated as 2*n1 - n2 and can be changed via distortion_product method.
  18. Parameters
  19. ----------
  20. n1 : list or int
  21. The lower harmonic number(s) for the stimuli.
  22. n2 : list or int
  23. The upper harmonic number(s) for the stimuli.
  24. voice : str
  25. The voice type of the source audio, setting the fundamental frequency range.
  26. Can either be 'male' or 'female'.
  27. source_dir : str or Path
  28. The directory containing the source audio files.
  29. target_dir : str or Path
  30. The directory where the generated stimuli will be saved.
  31. fs : int, optional
  32. The sampling frequency of the audio files, by default 44100.
  33. """
  34. def __init__(self, n1, n2, voice, source_dir, target_dir, fs=44100):
  35. self.fs = fs
  36. self.n1 = np.array(n1)
  37. self.n2 = np.array(n2)
  38. if len(self.n1) != len(self.n2):
  39. raise ValueError("n1 and n2 must have the same length.")
  41. self.dp = self.distortion_product(self.n1, self.n2)
  42. self.source_dir = Path(source_dir)
  43. self.target_dir = Path(target_dir)
  44. if not os.path.exists(self.target_dir):
  45. os.makedirs(self.target_dir)
  47. self.voice = voice
  49. if self.voice == 'female':
  50. self.f0_min, self.f0_max = 80, 300
  51. elif self.voice == 'male':
  52. self.f0_min, self.f0_max = 50, 200
  53. else:
  54. raise ValueError('Unknown voice.')
  56. #####################################################################
  57. def distortion_product(self, n1, n2):
  58. """Calculate the distortion product based on the provided harmonic numbers."""
  59. if isinstance(n1, Iterable) and isinstance(n2, Iterable):
  60. return 2 * np.array(n1) - np.array(n2)
  61. else:
  62. return 2 * n1 - n2
  64. def generate_sine_wave(self, frequency, duration, nrm=0.01):
  65. """Generate a sine wave of a given frequency and duration."""
  66. t = np.linspace(0, duration, int(self.fs * duration), endpoint=False)
  67. wave = nrm * np.sin(2 * np.pi * frequency * t)
  68. return wave
  70. def save_wave(self, wave, filename):
  71. """Save the generated waveform to a file."""
  72. if not os.path.exists(os.path.dirname(filename)):
  73. os.makedirs(os.path.dirname(filename))
  74. sf.write(filename, wave, self.fs)
  76. def zscore_norm(self, data):
  77. """Normalize the data using z-score normalization."""
  78. mean = np.mean(data)
  79. std = np.std(data)
  80. return (data - mean) / std
  82. ###################################################################
  84. def load_source_audio(self):
  85. """Load all audio files from the source directory."""
  86. self.source_files = sorted(list(self.source_dir.glob('*.wav')))
  87. if not self.source_files:
  88. raise FileNotFoundError("No .wav files found in the source directory.")
  89. return
  91. def determine_f0(self, audio_array, harm):
  92. """Estimate the fundamental frequency (f0) of the audio signal using the pyin algorithm.
  94. Parameters
  95. ----------
  96. audio_array : np.ndarray
  97. The audio signal from which to estimate the f0.
  98. harm : int
  99. The harmonic number for which to estimate the f0.
  101. Returns
  102. -------
  103. f0_mean : float
  104. The mean of the estimated f0 values.
  105. f0_std : float
  106. The standard deviation of the estimated f0 values.
  107. """
  108. # Parameters for pyin algorithm
  109. fr_length = 4000
  110. win_length = 3300
  111. hop_length = 1250
  113. # Estimate the fundamental frequency (f0)
  114. f0, voiced_flag, _ = librosa.pyin(audio_array, sr=self.fs, fmin=(harm*self.f0_min), fmax=(harm*self.f0_max), frame_length=fr_length, win_length=win_length, hop_length=hop_length)
  116. # Calculate mean and standard deviation of f0
  117. f0_mean = np.mean(f0[voiced_flag])
  118. f0_std = np.std(f0[voiced_flag])
  120. return f0_mean, f0_std
  122. #######################################################################
  124. def gen_fundamental_waveform(self, x, f0_mean, f0_std):
  125. """Generate the fundamental waveform of the audio signal x by bandpass filtering around the fundamental frequency of the signal.
  126. Filter bandwidth is defined as f0_mean +/- f0_std/2.
  128. Parameters
  129. ----------
  130. x : np.ndarray
  131. The audio signal from which to generate the fundamental waveform.
  132. f0_mean : float
  133. The mean of the estimated fundamental frequency.
  134. f0_std : float
  135. The standard deviation of the estimated fundamental frequency.
  137. Returns
  138. -------
  139. fund_wf : np.ndarray
  140. The generated fundamental waveform.
  141. """
  142. lowcut = np.round(f0_mean - f0_std/2, 1)
  143. highcut = np.round(f0_mean + f0_std/2, 1)
  145. fund_wf = butter_filter(x, [lowcut, highcut], 'bandpass', fs=self.fs)
  146. fund_wf = self.zscore_norm(fund_wf)
  148. return fund_wf
  150. def gen_stimuli_hilbert(self, n, fund_wf, nrm=0.01):
  151. """Generate the stimulus waveform for the nth harmonic overtone using the Hilbert transform of the fundamental waveform.
  153. Parameters
  154. ----------
  155. n : int
  156. The harmonic number for which to generate the stimulus waveform.
  157. fund_wf : np.ndarray
  158. The fundamental waveform of the audio signal.
  159. nrm : float, optional
  160. The normalization factor for the generated waveform, by default 0.01.
  162. Returns
  163. -------
  164. stim : np.ndarray
  165. The generated stimulus waveform for the nth harmonic overtone.
  166. """
  168. fund_wf_orig = fund_wf.copy()
  169. # remove nans from fund_wf and replace with zeros
  170. fund_wf = np.nan_to_num(fund_wf_orig)
  172. # as the hilbert transform expects a periodic signal, concatenate the waveform with itself
  173. fund_wf = np.concatenate((fund_wf[::-1], fund_wf))
  175. # apply the hilbert transform to get the amplitude and phase
  176. wf_hilbert = sig.hilbert(fund_wf)
  177. amp = np.abs(wf_hilbert[len(fund_wf_orig):])
  178. phase = np.unwrap(np.angle(wf_hilbert[len(fund_wf_orig):])) # halbe Länge, weil wir ja concatenated hatten
  180. stim = nrm * np.nan_to_num(amp * np.cos(phase * n))
  181. stim = stim - np.mean(stim) # remove DC offset
  183. return stim
  185. ####################################################################
  186. def create_pure_tone_stimuli(self, f1, f2, duration=120):
  187. """Creates pure tone stimuli based on the specified frequencies.
  189. Parameters
  190. ----------
  191. f1 : float
  192. The frequency of the first pure tone in Hz.
  193. f2 : float
  194. The frequency of the second pure tone in Hz.
  195. duration : float, optional
  196. The duration of the stimuli in seconds, by default 120 seconds.
  197. """
  198. pt_dp = self.distortion_product(f1, f2)
  199. stim1 = self.generate_sine_wave(f1, duration)
  200. stim2 = self.generate_sine_wave(f2, duration)
  201. stimdp = self.generate_sine_wave(pt_dp, duration)
  203. stereo_stim = np.vstack((stim1, stim2)).T
  205. self.save_wave(stereo_stim, self.target_dir.parent / f'stereo_pt.wav')
  206. self.save_wave(stimdp, self.target_dir.parent / f'dp_pt.wav')
  208. return
  210. def create_stimuli(self):
  211. """Create stimuli based on the source audio files and the specified harmonic numbers."""
  212. # Load source audio files
  213. self.load_source_audio()
  215. for audio_file in self.source_files:
  216. audio_name = audio_file.stem
  217. audio_array, _ = librosa.load(audio_file, sr=self.fs)
  218. audio_array = audio_array / np.max(np.abs(audio_array)) # normalize audio array
  219. #audio_array = audio_array - np.mean(audio_array) # remove DC offset
  221. stim_columns = ['filename', 'f0_mean', 'f0_std', 'harm', 'harm_freq [Hz]', 'harm_std [Hz]']
  223. csv_stimuli = []
  224. f0_mean, f0_std = self.determine_f0(audio_array, 1)
  226. # Generate the fundamental waveform
  227. fund_wf = self.gen_fundamental_waveform(audio_array, f0_mean, f0_std)
  229. # Generate and save stimulus waveforms
  230. for harms in [self.n1, self.n2, self.dp]:
  231. if isinstance(harms, Iterable):
  232. for n in harms:
  233. wf = self.gen_stimuli_hilbert(n, fund_wf)
  234. freq_stim, std_stim = self.determine_f0(wf, n)
  235. filename = f"{self.target_dir}/mono_stimuli/{audio_name}_n{n}.wav"
  236. self.save_wave(wf, filename)
  237. csv_stimuli.append([audio_name, f0_mean, f0_std, n, freq_stim, std_stim])
  239. else:
  240. n = harms
  241. wf = self.gen_stimuli_hilbert(n, fund_wf)
  242. freq_stim, std_stim = self.determine_f0(wf, n)
  243. filename = f"{self.target_dir}/mono_stimuli/{audio_name}_n{n}.wav" # das passt noch nicht
  244. self.save_wave(wf, filename)
  245. csv_stimuli.append([audio_name, f0_mean, f0_std, n, freq_stim, std_stim])
  247. self.determine_stimulus_correlations(audio_name)
  248. csv_stimuli.append(['-' * 10, '-' * 10, '-' * 10, '-' * 10, '-' * 10, '-' * 10]) # separator for different audio files
  250. csv_stimuli_df = pd.DataFrame(csv_stimuli, columns=stim_columns)
  251. csv_path = self.target_dir / f'stimuli_info.csv'
  252. write_header = not os.path.exists(csv_path)
  253. csv_stimuli_df.to_csv(csv_path, mode='a', header=write_header, index=False)
  256. def determine_stimulus_correlations(self, audio_name):
  257. """Determine the correlations between the generated stimuli and the distortion product waveform."""
  258. sig_columns = ['filename', 'n1', 'n2', 'dp', 'sig_peak']
  259. csv_correlations = []
  261. stim_path = self.target_dir / 'mono_stimuli/'
  262. plot_path = self.target_dir / 'mono_stimuli/Plots/'
  264. # determine stimulus correlations
  265. if isinstance(self.n1, Iterable):
  266. for n1, n2, dp in zip(self.n1, self.n2, self.dp):
  267. stim_n1 = librosa.load(stim_path / f'{audio_name}_n{n1}.wav', sr=self.fs)[0]
  268. stim_n2 = librosa.load(stim_path / f'{audio_name}_n{n2}.wav', sr=self.fs)[0]
  269. stim_dp = librosa.load(stim_path / f'{audio_name}_n{dp}.wav', sr=self.fs)[0]
  271. sig_peak = stimuli_correlation(dp, stim_dp, stim_n1, stim_n2, filename=plot_path / f"corr_{audio_name}_n{n1}n{n2}_dp{dp}.png", fs=self.fs)
  273. csv_correlations.append([audio_name, n1, n2, dp, sig_peak])
  274. else:
  275. # if n1, n2, dp are not lists, just use them directly
  276. stim_n1 = librosa.load(stim_path / f'{audio_name}_n{self.n1}.wav', sr=self.fs)[0]
  277. stim_n2 = librosa.load(stim_path / f'{audio_name}_n{self.n2}.wav', sr=self.fs)[0]
  278. stim_dp = librosa.load(stim_path / f'{audio_name}_n{self.dp}.wav', sr=self.fs)[0]
  280. sig_peak = stimuli_correlation(dp, stim_dp, stim_n1, stim_n2, filename=plot_path / f"corr_{audio_name}_n{self.n1}n{self.n2}_dp{self.dp}.png", fs=self.fs)
  282. csv_correlations.append([audio_name, self.n1, self.n2, self.dp, sig_peak])
  284. sig_df = pd.DataFrame(csv_correlations, columns=sig_columns)
  285. csv_path = self.target_dir / f'stimuli_correlations.csv'
  286. write_header = not os.path.exists(csv_path)
  287. sig_df.to_csv(csv_path, mode='a', header=write_header, index=False)
  289. return sig_peak
  291. def create_stereo_stimuli(self):
  292. """Create stereo stimuli by stacking the mono stimuli."""
  293. mono_stim_path = self.target_dir / 'mono_stimuli/'
  294. out_path = self.target_dir / 'stereo_stimuli/'
  295. self.load_source_audio()
  296. for audio_file in self.source_files:
  297. audio_name = audio_file.stem
  298. if isinstance(self.n1, list):
  299. for n1, n2 in zip(self.n1, self.n2):
  300. stim_n1 = librosa.load(mono_stim_path / f'{audio_name}_n{n1}.wav', sr=self.fs)[0]
  301. stim_n2 = librosa.load(mono_stim_path / f'{audio_name}_n{n2}.wav', sr=self.fs)[0]
  303. # create stereo stimulus
  304. stereo_stim = np.vstack((stim_n1, stim_n2)).T
  305. filename = out_path / f'{audio_name}_n{n1}n{n2}.wav'
  306. self.save_wave(stereo_stim, filename)
  308. else:
  309. stim_n1 = librosa.load(mono_stim_path / f'{audio_name}_n{self.n1}.wav', sr=self.fs)[0]
  310. stim_n2 = librosa.load(mono_stim_path / f'{audio_name}_n{self.n2}.wav', sr=self.fs)[0]
  312. # create stereo stimulus
  313. stereo_stim = np.vstack((stim_n1, stim_n2)).T
  314. filename = out_path / f'{audio_name}_n{self.n1}n{self.n2}.wav'
  315. self.save_wave(stereo_stim, filename)
  316. return
  319. class multiband_generator:
  320. def __init__(self, stim_directory, bookA, bookB=None, fs=44100):
  321. """
  322. Initialize the multiband generator with the directory containing stimuli and the books to be combined.
  323. Parameters
  324. ----------
  325. stim_directory : str or Path
  326. The directory where the stimulus files are located.
  327. bookA : str
  328. The name of the folder containing the mono stimuli for book A.
  329. Typically, it should follow the format 'Name_Voice'.
  330. bookB : str
  331. The name of the folder containing the mono stimuli for book B.
  332. Typically, it should follow the format 'Name_Voice'.
  333. If not provided, only book A will be used.
  334. fs : int, optional
  335. The sampling frequency of the audio files, by default 44100.
  336. """
  338. self.stim_directory = Path(stim_directory)
  339. self.bookA = bookA
  340. self.bookB = bookB
  341. self.fs = fs
  343. def distorion_product(self, n1, n2):
  344. """
  345. Calculate the distortion product based on the provided harmonic numbers.
  346. Parameters
  347. ----------
  348. n1 : int or list of int
  349. The first harmonic number(s).
  350. n2 : int or list of int
  351. The second harmonic number(s).
  352. Returns
  353. -------
  354. np.ndarray
  355. The distortion product waveform.
  356. """
  357. if isinstance(n1, Iterable) and isinstance(n2, Iterable):
  358. return 2 * np.array(n1) - np.array(n2)
  359. else:
  360. return 2 * n1 - n2
  362. def save_wave(self, wave, filename):
  363. """Save the generated waveform to a file."""
  364. if not os.path.exists(os.path.dirname(filename)):
  365. os.makedirs(os.path.dirname(filename))
  366. sf.write(filename, wave, self.fs)
  368. def extract_chapter_number(self, filename):
  369. """Extract the chapter number from the filename."""
  370. base = re.sub(r'_n\d+$', '', filename) # remove the n1 or n2 suffix
  371. match = re.findall(r'(?<!\d)(\d{2})(?!\d)', base) # find two-digit numbers
  372. return match[0] if match else None
  374. def load_stim_files(self, book):
  375. """Load all audio files for the respective book from the stimulus directory."""
  376. mono_stim_path = self.stim_directory / book / 'mono_stimuli'
  377. stim_files = sorted(list(mono_stim_path.glob('*.wav')))
  379. if not stim_files:
  380. raise FileNotFoundError("No .wav files found in the stimulus directory.")
  381. return stim_files
  383. def create_multiband_singlespeaker(self, all_n1, all_n2, book, nrm=0.01):
  384. """Create multiband stimuli by combining the mono stimuli from book A and book B.
  385. The resulting stimuli will be saved in a new directory named 'multiband_stimuli'.
  387. Parameters
  388. ----------
  389. all_n1 : list of int
  390. The harmonic numbers for the first band that will be combined.
  391. all_n2 : list of int
  392. The harmonic numbers for the second band that will be combined.
  393. book : str
  394. The name of the book for which the multiband stimuli will be created.
  395. nrm : float, optional
  396. The normalization factor for the generated waveform, by default 0.01.
  397. """
  398. # Create target directory for multiband stimuli
  399. target_dir = self.stim_directory / book / 'multiband_stimuli'
  400. if not os.path.exists(target_dir):
  401. os.makedirs(target_dir)
  403. # Load stimuli for book A only
  404. mono_stimuli = self.load_stim_files(book)
  405. chapters = sorted(set(self.extract_chapter_number(file.stem) for file in mono_stimuli if 'single' in file.stem))
  407. for chapter in chapters:
  408. chapter_files = [file for file in mono_stimuli if self.extract_chapter_number(file.stem) == chapter and 'single' in file.stem]
  409. base_name = '_'.join(chapter_files[0].stem.split('_')[:3])
  410. harms_name = ''.join([f'n{n1}' for n1 in all_n1]) + '_' + ''.join([f'n{n2}' for n2 in all_n2])
  411. multiband_n1 = np.array([])
  412. multiband_n2 = np.array([])
  414. n1_files = [file for file in chapter_files if any(f'n{n1}' in file.stem for n1 in all_n1)]
  415. n2_files = [file for file in chapter_files if any(f'n{n2}' in file.stem for n2 in all_n2)]
  417. if len(n1_files) != len(n2_files):
  418. raise ValueError(f"Number of n1 and n2 files do not match for chapter {chapter} in book {book}.")
  420. for n1_file, n2_file in zip(n1_files, n2_files):
  421. # Load the audio files
  422. stim_n1, _ = librosa.load(n1_file, sr=self.fs)
  423. stim_n2, _ = librosa.load(n2_file, sr=self.fs)
  425. if multiband_n1.shape[0] == 0 and multiband_n2.shape[0] == 0:
  426. multiband_n1 = stim_n1
  427. multiband_n2 = stim_n2
  428. else:
  429. multiband_n1 += stim_n1
  430. multiband_n2 += stim_n2
  432. # Normalize the multiband stimuli
  433. multiband_n1 = nrm * multiband_n1 / np.max(np.abs(multiband_n1))
  434. multiband_n2 = nrm * multiband_n2 / np.max(np.abs(multiband_n2))
  436. # remove DC offset
  437. multiband_n1 = multiband_n1 - np.mean(multiband_n1)
  438. multiband_n2 = multiband_n2 - np.mean(multiband_n2)
  440. # save them as stereo stimuli
  441. multiband_stim = np.vstack((multiband_n1, multiband_n2)).T
  442. filename = target_dir / f'{base_name}_{harms_name}.wav'
  443. self.save_wave(multiband_stim, filename)
  445. # calculate correlation between dp waveforms and multiband stimuli
  446. dp = self.distorion_product(all_n1, all_n2)
  447. dp_files = [file for file in chapter_files if any(f'n{d}' in file.stem for d in dp)]
  449. sig_peak = []
  450. for ndp, dp_file in zip(dp, dp_files):
  451. wf_dp, _ = librosa.load(dp_file, sr=self.fs)
  452. sig_peak.append(stimuli_correlation(ndp, wf_dp, multiband_n1, multiband_n2, filename=target_dir / f"corr_{base_name}_{harms_name}_dp{ndp}.png", fs=self.fs))
  454. # Save the correlation results to a CSV file
  455. multiband_columns = ['filename', 'n1', 'n2', 'dp', 'sig_peak']
  456. multiband_data = np.array([[base_name for i in range(len(sig_peak))], ['n'.join(map(str, all_n1)) for i in range(len(sig_peak))], ['n'.join(map(str, all_n2)) for i in range(len(sig_peak))], list(dp), sig_peak]).T
  457. multiband_csv = pd.DataFrame(multiband_data, columns=multiband_columns)
  459. csv_path = self.stim_directory / book / f'multiband_correlations_{book}_{harms_name}.csv'
  460. write_header = not os.path.exists(csv_path)
  461. multiband_csv.to_csv(csv_path, mode='a', header=write_header, index=False)
  463. return
  466. def create_multiband_competingspeaker(self, bookA, bookB, A_n1, A_n2, B_n1, B_n2, nrm=0.01):
  467. """Create multiband stimuli by combining the mono stimuli from book A and book B.
  468. The resulting stimuli will be saved in a new directory named 'competing_stimuli_{bookA}_{bookB}'.
  470. Parameters
  471. ----------
  472. bookA : str
  473. The name of the folder containing the mono stimuli for book A.
  474. bookB : str
  475. The name of the folder containing the mono stimuli for book B.
  476. A_n1 : list of int
  477. The harmonic numbers for the first band in book A that will be combined.
  478. A_n2 : list of int
  479. The harmonic numbers for the second band in book A that will be combined.
  480. B_n1 : list of int
  481. The harmonic numbers for the first band in book B that will be combined.
  482. B_n2 : list of int
  483. The harmonic numbers for the second band in book B that will be combined.
  484. nrm : float, optional
  485. The normalization factor for the generated waveform, by default 0.01.
  486. """
  487. target_dir = self.stim_directory / f'competing_stimuli_{self.bookA}_{self.bookB}'
  488. if not os.path.exists(target_dir):
  489. os.makedirs(target_dir)
  491. stim_bookA = self.load_stim_files(bookA)
  492. stim_bookB = self.load_stim_files(bookB)
  494. # remove potential single speaker files
  495. stim_bookA = [file for file in stim_bookA if 'single' not in file.stem]
  496. stim_bookB = [file for file in stim_bookB if 'single' not in file.stem]
  498. chapters_A = sorted(set(self.extract_chapter_number(file.stem) for file in stim_bookA))
  499. chapters_B = sorted(set(self.extract_chapter_number(file.stem) for file in stim_bookB))
  501. if chapters_A != chapters_B:
  502. raise ValueError("Chapters in book A and book B do not match.")
  504. for chapter in chapters_A:
  505. chapter_files_A = [file for file in stim_bookA if self.extract_chapter_number(file.stem) == chapter]
  506. chapter_files_B = [file for file in stim_bookB if self.extract_chapter_number(file.stem) == chapter]
  508. base_name = 'Ch_' + chapter
  509. harms_A = ''.join([f'n{n1}' for n1 in A_n1]) + '_' + ''.join([f'n{n2}' for n2 in A_n2])
  510. harms_B = ''.join([f'n{n1}' for n1 in B_n1]) + '_' + ''.join([f'n{n2}' for n2 in B_n2])
  512. multiband_n1 = np.array([])
  513. multiband_n2 = np.array([])
  515. n1_files_A = [file for file in chapter_files_A if any(f'n{n1}' in file.stem for n1 in A_n1)]
  516. n2_files_A = [file for file in chapter_files_A if any(f'n{n2}' in file.stem for n2 in A_n2)]
  517. n1_files_B = [file for file in chapter_files_B if any(f'n{n1}' in file.stem for n1 in B_n1)]
  518. n2_files_B = [file for file in chapter_files_B if any(f'n{n2}' in file.stem for n2 in B_n2)]
  520. if len(n1_files_A) != len(n2_files_A) or len(n1_files_B) != len(n2_files_B):
  521. raise ValueError(f"Number of n1 and n2 files do not match for chapter {chapter}.")
  523. for n1_file_A, n1_file_B, n2_file_A, n2_file_B in zip(n1_files_A, n1_files_B, n2_files_A, n2_files_B):
  524. # Load the audio files
  525. stim_n1_A, _ = librosa.load(n1_file_A, sr=self.fs)
  526. stim_n2_A, _ = librosa.load(n2_file_A, sr=self.fs)
  527. stim_n1_B, _ = librosa.load(n1_file_B, sr=self.fs)
  528. stim_n2_B, _ = librosa.load(n2_file_B, sr=self.fs)
  530. if len(stim_n1_A) > len(stim_n1_B):
  531. stim_n1_B = np.pad(stim_n1_B, (0, len(stim_n1_A) - len(stim_n1_B)), 'constant')
  532. elif len(stim_n1_B) > len(stim_n1_A):
  533. stim_n1_A = np.pad(stim_n1_A, (0, len(stim_n1_B) - len(stim_n1_A)), 'constant')
  535. if len(stim_n2_A) > len(stim_n2_B):
  536. stim_n2_B = np.pad(stim_n2_B, (0, len(stim_n2_A) - len(stim_n2_B)), 'constant')
  537. elif len(stim_n2_B) > len(stim_n2_A):
  538. stim_n2_A = np.pad(stim_n2_A, (0, len(stim_n2_B) - len(stim_n2_A)), 'constant')
  540. if multiband_n1.shape[0] == 0 and multiband_n2.shape[0] == 0:
  541. multiband_n1 = stim_n1_A + stim_n1_B
  542. multiband_n2 = stim_n2_A + stim_n2_B
  543. else:
  544. multiband_n1 += stim_n1_A + stim_n1_B
  545. multiband_n2 += stim_n2_A + stim_n2_B
  547. # Normalize the multiband stimuli
  548. multiband_n1 = nrm * multiband_n1 / np.max(np.abs(multiband_n1))
  549. multiband_n2 = nrm * multiband_n2 / np.max(np.abs(multiband_n2))
  551. # save them as stereo stimuli
  552. multiband_stim = np.vstack((multiband_n1, multiband_n2)).T
  553. filename = target_dir / f'{base_name}_{bookA}_{harms_A}_{bookB}_{harms_B}.wav'
  554. self.save_wave(multiband_stim, filename)
  556. # calculate correlation between dp waveforms and multiband stimuli
  557. dp_A = self.distorion_product(A_n1, A_n2)
  558. dp_B = self.distorion_product(B_n1, B_n2)
  559. dp_files_A = [file for file in chapter_files_A if any(f'n{d}' in file.stem for d in dp_A)]
  560. dp_files_B = [file for file in chapter_files_B if any(f'n{d}' in file.stem for d in dp_B)]
  562. sig_peak = []
  563. for i, (dp_file_A, dp_file_B) in enumerate(zip(dp_files_A, dp_files_B)):
  564. wf_dp_A, _ = librosa.load(dp_file_A, sr=self.fs)
  565. wf_dp_B, _ = librosa.load(dp_file_B, sr=self.fs)
  567. res_A = stimuli_correlation(dp_A[i], wf_dp_A, multiband_n1, multiband_n2, filename=target_dir / f"corr_{base_name}_{bookA}_dp{dp_A[i]}.png", fs=self.fs)
  568. res_B = stimuli_correlation(dp_B[i], wf_dp_B, multiband_n1, multiband_n2, filename=target_dir / f"corr_{base_name}_{bookB}_dp{dp_B[i]}.png", fs=self.fs)
  570. sig_peak.append((res_A, res_B))
  572. # Save the correlation results to a CSV file
  573. multiband_columns = ['filename', 'book A', 'book B', 'n1 (book A)', 'n2 (book A)', 'dp (book A)', 'n1 (book B)', 'n2 (book B)', 'dp (book B)', 'sig_peak_A', 'sig_peak_B']
  574. multiband_data = np.array([[base_name for i in range(len(sig_peak))], [bookA for i in range(len(sig_peak))], [bookB for i in range(len(sig_peak))], ['n'.join(map(str, A_n1)) for i in range(len(sig_peak))], ['n'.join(map(str, A_n2)) for i in range(len(sig_peak))], list(dp_A), ['n'.join(map(str, B_n1)) for i in range(len(sig_peak))], ['n'.join(map(str, B_n2)) for i in range(len(sig_peak))], list(dp_B),[res[0] for res in sig_peak], [res[1] for res in sig_peak]]).T
  575. multiband_csv = pd.DataFrame(multiband_data, columns=multiband_columns)
  576. csv_path = self.stim_directory / f'multiband_correlations_{bookA}_{harms_A}_{bookB}_{harms_B}.csv'
  577. write_header = not os.path.exists(csv_path)
  578. multiband_csv.to_csv(csv_path, mode='a', header=write_header, index=False)
  580. return
  582. def mix_books(self, audio_path, bookA, bookB, nrm=0.02):
  583. """Mix the audio files from book A and book B into stereo stimuli.
  584. The resulting stimuli will be saved in a new directory named 'competing_audios_{bookA}_{bookB}'.
  586. Parameters
  587. ----------
  588. audio_path : str or Path
  589. The directory where the source audio files are located.
  590. bookA : str
  591. The name of the folder containing the audio files for book A.
  592. bookB : str
  593. The name of the folder containing the audio files for book B.
  594. nrm : float, optional
  595. The normalization factor for the generated waveform, by default 0.02.
  596. """
  597. audio_path = Path(audio_path)
  598. single_dir = audio_path.parent / 'single_audios/'
  599. if not os.path.exists(single_dir):
  600. os.makedirs(single_dir)
  601. target_dir = audio_path.parent / f'competing_audios_{self.bookA}_{self.bookB}'
  602. if not os.path.exists(target_dir):
  603. os.makedirs(target_dir)
  605. path_bookA = audio_path / bookA
  606. path_bookB = audio_path / bookB
  608. source_files_A = sorted(list(path_bookA.glob('*.wav')))
  609. source_files_B = sorted(list(path_bookB.glob('*.wav')))
  611. # extract potential single speaker files
  612. source_files_single = [file for file in source_files_A + source_files_B if 'single' in file.stem]
  614. # save single speaker files separately
  615. for file in source_files_single:
  616. single_audio = librosa.load(file, sr=self.fs)[0]
  617. single_audio = nrm * single_audio / np.max(np.abs(single_audio))
  618. self.save_wave(single_audio, single_dir / file.name)
  620. source_files_A = [file for file in source_files_A if file not in source_files_single]
  621. source_files_B = [file for file in source_files_B if file not in source_files_single]
  623. if len(source_files_A) != len(source_files_B):
  624. raise ValueError(f"Number of audio files in {bookA} and {bookB} do not match.")
  626. # mix remaining chapters together
  627. chapters_A = sorted(set(self.extract_chapter_number(file.stem) for file in source_files_A))
  628. chapters_B = sorted(set(self.extract_chapter_number(file.stem) for file in source_files_B))
  630. if chapters_A != chapters_B:
  631. raise ValueError("Chapters in book A and book B do not match.")
  633. for chapter in chapters_A:
  634. chapter_files_A = [file for file in source_files_A if self.extract_chapter_number(file.stem) == chapter]
  635. chapter_files_B = [file for file in source_files_B if self.extract_chapter_number(file.stem) == chapter]
  637. base_name = 'Ch_' + chapter
  639. audio_A = librosa.load(chapter_files_A[0], sr=self.fs)[0]
  640. audio_B = librosa.load(chapter_files_B[0], sr=self.fs)[0]
  642. audio_A = nrm * audio_A / np.max(np.abs(audio_A))
  643. audio_B = nrm * audio_B / np.max(np.abs(audio_B))
  645. if len(audio_A) > len(audio_B):
  646. audio_B = np.pad(audio_B, (0, len(audio_A) - len(audio_B)), 'constant')
  647. elif len(audio_B) > len(audio_A):
  648. audio_A = np.pad(audio_A, (0, len(audio_B) - len(audio_A)), 'constant')
  650. mixed_audio = np.vstack((audio_A, audio_B)).T
  651. filename = target_dir / f'{base_name}_{bookA}_{bookB}.wav'
  652. self.save_wave(mixed_audio, filename)
  654. return

stimulus_generation.py at commit 026e5b7, under MIT · at the source

Overview

Authors: Janna Steinebach1, Tobias Reichenbach1
ORCID iDs: Janna Steinebach
  1. Department Artificial Intelligence in Biomedical Engineering, Friedrich-Alexander-Universität Erlangen-Nürnberg, Erlangen, Germany
Institutions: Friedrich-Alexander-Universität Erlangen-Nürnberg (Germany)
Journal: Frontiers in neuroscience, volume 20, article 1756386
Dates: received 28 November 2025; accepted 4 February 2026; published online 2 March 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fnins.2026.1756386 · PMID 41847227 · PMCID PMC12989502 · OpenAlex W7133229558
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Statistics, Machine learning, Preprocessing
Keywords: auditory attention, distortion products, efferent feedback, inner ear biology, MOC system, otoacoustic emissions, speech processing
Topic: Hearing, Cochlea, Tinnitus, Genetics (Sensory Systems, Neuroscience), according to OpenAlex
Funding: Deutsche Forschungsgemeinschaft (DFG)
Citations: not cited yet (Europe PMC); 66 references in the paper

Abstract

Humans are remarkably skilled at understanding speech in noisy environments. While segregation of different audio streams is mostly accomplished in the auditory cortex, neural feedback connections run from the cortex to the brainstem and to the cochlea. The latter organ not only houses the mechanosensitive hair cells, but also possesses an active process enabling it to amplify sound in a frequency-dependent manner. A physiological correlate of the active process are distortion-product otoacoustic emissions (DPOAEs) that can be measured non-invasively from the ear canal. Here we employed speech-like DPOAEs, measured in response to stimuli derived from natural human speech and thus reflecting the harmonic spectral structure of voiced speech. We show that these emissions are modulated by selective attention to one of two competing voices, as well as by intermodal attention. Specifically, speech-like DPOAEs evoked by stimuli related to resolved harmonics of a voice were significantly reduced when that voice was attended compared to when it was ignored. No such effect was observed for stimuli related to unresolved harmonics of the target voice when the competing voice's harmonics in that range were unresolved as well, indicating that attentional modulation is specific to those components of voiced speech that are spectrally resolved. Our findings support the hypothesis that the cochlea's active process already shapes selective attention to speech in noise. Moreover, the speech-like DPOAEs that we developed open up further possibilities for investigating the contribution of the cochlear active process to auditory scene analysis in naturalistic settings.

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 4 matches between paragraphs and lines of code.

janna-stb/dpoae_attention_study

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 026e5b711d983c50894d168c83b8fadc4f918fa5, 1 December 2025
Languages: Python (12)
Size: 15 files, 12 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README, license file, CITATION.cff
Not found: environment file, tests, continuous integration, documentation
Tools: NumPy (7 files), Matplotlib (5 files), pandas (4 files), SciPy (4 files), seaborn (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
14 files
At the source: github.com/janna-stb/dpoae_attention_study.git

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;
  • 12 scripts, each with its path and the digest of its content;
  • 4 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 availability statement

All custom code used for stimulus generation, speech-like DPOAE analysis via cross-correlation, and statistical evaluation is openly available on GitHub at https://github.com/janna-stb/dpoae_attention_study.git under the MIT License.

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, 30 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 2 authors, 7 keywords, 1 funder, 60 references.

Cite

This paper

Steinebach, J., & Reichenbach, T. (2026). Attention to speech modulates distortion product otoacoustic emissions evoked by speech-derived stimuli in humans. Frontiers in neuroscience, 20, 1756386. https://doi.org/10.3389/fnins.2026.1756386

BibTeX

@article{steinebach2026attention,
author = {Steinebach, Janna and Reichenbach, Tobias},
title = {{Attention to speech modulates distortion product otoacoustic emissions evoked by speech-derived stimuli in humans}},
journal = {Frontiers in neuroscience},
year = {2026},
month = mar,
volume = {20},
pages = {1756386},
publisher = {Frontiers Media SA},
issn = {1662-4548},
doi = {10.3389/fnins.2026.1756386},
url = {https://doi.org/10.3389/fnins.2026.1756386},
pmid = {41847227},
pmcid = {PMC12989502}
}

RIS

TY - JOUR
AU - Steinebach, Janna
AU - Reichenbach, Tobias
TI - Attention to speech modulates distortion product otoacoustic emissions evoked by speech-derived stimuli in humans
T2 - Frontiers in neuroscience
J2 - Front Neurosci
PY - 2026
DA - 2026/03/02
VL - 20
SP - 1756386
SN - 1662-4548
PB - Frontiers Media SA
DO - 10.3389/fnins.2026.1756386
UR - https://doi.org/10.3389/fnins.2026.1756386
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fnins.2026.1756386",
"type": "article-journal",
"title": "Attention to speech modulates distortion product otoacoustic emissions evoked by speech-derived stimuli in humans",
"container-title": "Frontiers in neuroscience",
"author": [
{
"family": "Steinebach",
"given": "Janna"
},
{
"family": "Reichenbach",
"given": "Tobias"
}
],
"container-title-short": "Front Neurosci",
"volume": "20",
"page": "1756386",
"DOI": "10.3389/fnins.2026.1756386",
"PMID": "41847227",
"PMCID": "PMC12989502",
"ISSN": "1662-4548",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fnins.2026.1756386",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
2
]
]
}
}

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.1038/s41562-026-02414-7 [code]
Optimized feature gains explain and predict successes and failures of human selective listening.
Journal: Nature human behaviour
In common: statsmodels, seaborn, pandas, 3 other tools, cognitive, 4 references
[2] doi:10.7554/elife.100056 [code]
Multi-talker speech comprehension at different temporal scales in listeners with normal and impaired hearing.
Journal: eLife
In common: pandas, SciPy, NumPy, cognitive, 4 references
[3] doi:10.1523/eneuro.0041-26.2026 [code]
Ocular Speech Tracking Persists in Blindness, but Its Dynamics and Oculo-Cerebral Connectivity Depend on Visual Status.
Journal: eNeuro
In common: statsmodels, seaborn, pandas, 3 other tools, cognitive, 1 reference
[4] doi:10.1111/psyp.70397 [code]
Cortical Contributions to Attentional Orienting and Response Cancellation in Action Stopping.
Journal: Psychophysiology
In common: statsmodels, seaborn, pandas, 3 other tools, cognitive, 1 reference
[5] doi:10.1016/j.ibneur.2026.05.013 [code]
Anticipatory slow potentials before auditory feedback show posterior predominance but limited condition effects in speech-in-noise.
Journal: IBRO neuroscience reports
In common: statsmodels, pandas, SciPy, 2 other tools, cognitive, 1 reference
[6] doi:10.1162/imag.a.1286 [code]
Behavioral imitation with artificial neural networks leads to personalized models of brain dynamics during videogame play.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: statsmodels, seaborn, pandas, 3 other tools, 1 reference
[7] doi:10.1162/imag.a.1256 [code]
Gamer in the scanner: Event-related analysis of fMRI activity during retro videogame play guided by automated annotations of game content.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: statsmodels, seaborn, pandas, 3 other tools, 1 reference
[8] doi:10.34133/csbj.0042 [code]
Using Steady-State Visual Evoked Potentials to Characterize Wide-Ranging Retinopathy Linked to &lt;i&gt;CRB1&lt;/i&gt;: Implications for Clinical Trials.
Journal: Computational and structural biotechnology journal
In common: statsmodels, seaborn, pandas, 3 other tools, 1 reference
[9] 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: statsmodels, seaborn, pandas, 3 other tools, 1 reference
[10] doi:10.1073/pnas.2536563123 [code]
Temporally structured motor and auditory representations in covert syllable production.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: statsmodels, pandas, SciPy, 2 other tools, cognitive, 1 reference

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.