OSCR

Benchmarking criteria to determine latent linear dimensionality in neural data.

Code ↔ Paper

19 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 19 matches · 5 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Results ↔ MATLAB Package/simulate_data_matrix.m, lines 1–113 · score 0.80 · decay factor, soft normalization, noise distribution, noise factor, varied, tuning
  2. [2] § Methods › Simulations ↔ MATLAB Package/simulate_data_matrix.m, lines 1–113 · score 0.73 · linear combinations, simulated neural, linear simulations, activation, Gaussian, latent variables
  3. [3] § Methods › Criteria for dimensionality estimation ↔ MATLAB Package/optimal_SVHT_coef.m, lines 1–68 · score 0.70 · optimal hard threshold, unknown noise, Donoho, Gavish, singular, coefficient
  4. [4] § Results ↔ MATLAB Package/dimensionality_DEMO.m, lines 8–30 · score 0.69 · decay factor, soft normalization, noise distribution, noise factor, Poisson, Gaussian
  5. [5] § Methods › Variance decay rate of a matrix ↔ MATLAB Package/simulate_data_matrix.m, lines 181–219 · score 0.69 · power law function, exponential decay, latent variables, simulations, matrices, components
  6. [6] § Methods › Criteria for dimensionality estimation ↔ MATLAB Package/singval_hard_threshold.m, the whole file · a weak match · score 0.67 · optimal hard threshold, Donoho, Gavish, singular, unknown, coefficient
  7. [7] § Methods › Criteria for dimensionality estimation ↔ MATLAB Package/kaiser_rule.m, the whole file · a weak match · score 0.67 · Kaiser rule, original variables, variance explained, eigenvalues, scored, PCA
  8. [8] § Methods › Criteria for dimensionality estimation ↔ MATLAB Package/eval_num_PCs_cross_val.m, lines 88–165 · score 0.66 · bi cross validation, ALS, algorithms, train, fold, iterative
  9. [9] § Results › Criteria comparison on linear datasets ↔ MATLAB Package/optimal_SVHT_coef.m, lines 1–68 · score 0.66 · low rank, denoised matrix, Hard Thresholding, Donoho, Gavish, Singular
  10. [10] § Methods › Variance decay rate of a matrix ↔ MATLAB Package/fit_power_law.m, the whole file · a weak match · score 0.64 · power law, fitted, explained variance, exponential, PCs, components
  11. [11] § Methods › Metrics for criteria comparison ↔ MATLAB Package/simulate_data_matrix.m, lines 304–368 · score 0.63 · noise variance, fake units, variance explained, fitted, R2, scored
  12. [12] § Methods › Simulations ↔ MATLAB Package/simulate_data_matrix.m, lines 221–260 · score 0.58 · noise matrix, sp, Subtracting, firing, bins, Poisson
  13. [13] § Methods › Simulations ↔ MATLAB Package/simulate_data_matrix.m, lines 181–219 · score 0.56 · exponential decay, decay factor, orthogonalized, latent variable, scored, simulation
  14. [14] § Results › Criteria comparison on linear datasets ↔ MATLAB Package/singval_hard_threshold.m, the whole file · a weak match · score 0.56 · optimal Singular, Hard Thresholding, Donoho, Gavish, rank, median
  15. [15] § Results › The effect of non-linearities on latent structure recovery ↔ MATLAB Package/eval_num_PCs_cross_val.m, lines 1–45 · score 0.54 · cross validation schemes, bi cross validation, deviation, R2, imputation, reconstruction
  16. [16] § Methods › Simulations ↔ MATLAB Package/dimensionality_DEMO.m, lines 8–30 · score 0.54 · soft normalization, noise distribution, Poisson, Gaussian, latent variable, synthetic
  17. [17] § Methods › Criteria for dimensionality estimation ↔ MATLAB Package/eval_num_PCs_cross_val.m, lines 88–165 · score 0.54 · bi cross validation, train, predictions, iterations, imputation, reconstruction
  18. [18] § Methods › Criteria for dimensionality estimation ↔ MATLAB Package/parallel_analysis.m, the whole file · a weak match · score 0.54 · covariance matrix, Parallel, descending, disrupting, eigenvalues, threshold
  19. [19] § Methods › Simulations ↔ MATLAB Package/simulate_data_matrix.m, lines 221–260 · score 0.50 · firing rate, subtracted, weight, FAKE, scoring, simulation

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

MATLAB · 368 lines · 15 KB · MIT · 7 matches

  1. function [X, varargout] = simulate_data_matrix(fake_units, time_series_length, num_latent, settings)
  2. %--------------------------------------------------------------------------
  3. % SIMULATE_DATA_MATRIX Generate synthetic data with controlled latent structure
  4. %
  5. % Designed for generating synthetic neural-like data with known underlying dimensionality and
  6. % noise characteristics. Simulates a data matrix based on linear combinations of latent variables plus
  7. % noise. The degree of non-linearity mapping between latent activations and simulated neural activity
  8. % can be tuned. Other parameters can be varied (see below).
  9. %
  10. % Syntax:
  11. % X = simulate_data_matrix(fake_units, time_series_length, num_latent)
  12. % [X, output] = simulate_data_matrix(fake_units, time_series_length, num_latent, settings)
  13. % [X, output, settings] = simulate_data_matrix(fake_units, time_series_length, num_latent, settings)
  14. %
  15. % Inputs:
  16. % fake_units - Number of variables/units to generate (e.g., neurons)
  17. % time_series_length - Length of time series (number of timepoints)
  18. % num_latent - Number of latent variables defining data structure
  19. % settings - (Optional) struct with fields:
  20. % .gen - Latent generation method: 'random','sine','PCs','dynamical' (default:'random')
  21. % .noiseDistr - Noise distribution: 'gaussian' or 'poisson' (default:'gaussian')
  22. % .nonLinAlfa - Non-linearity strength parameter (default:0)
  23. % .decayFactor - Decay factor for scaling latents (default:0.5)
  24. % .decayCap - Cap decay to maintain latent structure (default:false)
  25. % .noiseFactor - Scale factor for noise amplitude (default:1)
  26. % .equalNoise - Use equal noise across units (default:false)
  27. % .soft_norm - Use soft normalization instead of z-score (default:false)
  28. % .display - Plot diagnostic figures (default:false)
  29. %
  30. % Outputs:
  31. % X - Simulated data matrix (time_series_length x fake_units)
  32. % output - (Optional) struct with fields:
  33. % .single_L_var - Variance explained by each latent
  34. % .single_L_SNR - Signal-to-noise ratio for each latent
  35. % .L_R2s - R-squared values for latent reconstructions
  36. % .L_var - Total variance explained by linear structure
  37. % .U_var - Total variance in combined latents
  38. % .noise_var - Variance explained by noise
  39. % .nonLinear_var - Variance from non-linear effects
  40. % .L - Raw latent variables matrix
  41. % .U - Combined latent representation
  42. % .noise_matrix - Generated noise matrix
  43. % .tau - variance decay for X
  44. % .settings - Copy of input settings
  45. % .fake_units - Number of units generated
  46. % .time_series_length - Length of time series
  47. % .num_latent - Number of latent dimensions
  48. % settings - (Optional) Copy of settings struct with defaults filled in
  49. %
  50. % Example:
  51. % % Generate 100 units with 5 latents over 1000 timepoints
  52. % settings = struct('gen','sine','noiseFactor',0.5,'display',true);
  53. % [X,stats] = simulate_data_matrix(100, 1000, 5, settings);
  54. %
  55. % Author: Francesco E. Vaccari, PhD
  56. % Date: September 24, 2025
  57. %--------------------------------------------------------------------------
  59. % --- Handle settings structure input ---
  60. if nargin < 4
  61. settings = struct();
  62. end
  63. if ~isfield(settings, 'gen') | isnan(settings.gen), settings.gen = 'random'; end
  64. if ~isfield(settings, 'noiseDistr') | isnan(settings.noiseDistr), settings.noiseDistr = 'gaussian'; end
  65. if ~isfield(settings, 'nonLinAlfa') | isnan(settings.nonLinAlfa), settings.nonLinAlfa = 0; end
  66. if ~isfield(settings, 'decayFactor') | isnan(settings.decayFactor), settings.decayFactor = 0.5; end
  67. if ~isfield(settings, 'decayCap') | isnan(settings.decayCap), settings.decayCap = false; end
  68. if ~isfield(settings, 'noiseFactor') | isnan(settings.noiseFactor), settings.noiseFactor = 1; end
  69. if ~isfield(settings, 'equalNoise') | isnan(settings.equalNoise), settings.equalNoise = false; end
  70. if ~isfield(settings, 'soft_norm') | isnan(settings.soft_norm), settings.soft_norm = false; end
  71. if ~isfield(settings, 'display') | isnan(settings.display), settings.display = false; end
  73. % Simulate!
  74. if settings.decayCap %if decay is capped
  76. settingsTemp = settings;
  77. settingsTemp.nonLinAlfa = 0; %set linear simulation
  78. settingsTemp.display = false;
  80. while true
  81. [X, output] = simulate(fake_units, time_series_length, num_latent, settingsTemp);
  82. % [coeff, score] = pca(X);
  83. %
  84. % for k = 1:num_latent
  85. % Xhat = score(:,1:k)*coeff(:,1:k)';
  86. % error(k) = sumsqr(output.U - Xhat);
  87. % end
  89. [k_opt, vv] = find_optimality(X, output);
  91. % if error(num_latent) > min(error) %any(output.single_L_SNR < 2/3) %if the last PC contains more noise than signal
  92. if k_opt ~= num_latent
  93. settingsTemp.decayFactor = settingsTemp.decayFactor*0.8; %reduce the decayFactor by 10% and run another simulation
  94. else
  95. settings.decayFactor = settingsTemp.decayFactor; %set the final decayFactor to be equal to the last one
  96. break
  97. end
  99. end
  101. else
  102. [X, output] = simulate(fake_units, time_series_length, num_latent, settings); %run the output simulation
  103. end
  107. % Check the number of outputs requested and return accordingly
  108. if nargout == 2
  109. varargout{1} = output; % Return the struct as the second output
  110. elseif nargout == 3
  111. varargout{1} = output; % Return the struct as the second output
  112. varargout{2} = settings; % Return the struct as the third output
  113. end
  116. function [X, output] = simulate(fake_units, time_series_length, num_latent, settings)
  118. % Assign settings fields to variables used below without changing any other commands
  119. gen = settings.gen;
  120. decayFactor = settings.decayFactor;
  121. decayCap = settings.decayCap;
  122. noiseFactor = settings.noiseFactor;
  123. equalNoise = settings.equalNoise;
  124. soft_norm = settings.soft_norm;
  125. display = settings.display;
  127. tmp_num_latent = num_latent;
  128. for i = 1:10
  129. switch gen
  130. case 'random'
  131. % Generate random time series (stochastic)
  132. L = generate_random_time_series(tmp_num_latent, time_series_length);
  133. case 'sine'
  134. % Generate sine-wave based time series
  135. L = generate_random_sine_series(tmp_num_latent, time_series_length);
  136. case 'PCs'
  137. % Generate time series based on principal components
  138. L = generate_random_units_from_PCs(tmp_num_latent, time_series_length);
  139. case 'dynamical'
  140. L = generate_random_dynamical_series(tmp_num_latent, time_series_length);
  141. end
  144. % Pre-process latent data (z-score, orthogonalize, and z-score again)
  145. L = zscore(L);
  147. if rank(L) == num_latent
  148. break
  149. else
  150. tmp_num_latent = tmp_num_latent+1;
  151. end
  153. end
  155. num_latent = rank(L);
  157. if display
  158. % Plot statistics of latent variables BEFORE orthogonalization and scaling
  159. figure
  160. subplot(1, 3, 1)
  161. bar(var(L))
  162. ylabel('Variance')
  163. xlabel('Dimensions')
  164. title('Latent Variables Variance')
  166. subplot(1, 3, 2)
  167. imagesc(corr(L))
  168. ylabel('Dimensions')
  169. xlabel('Dimensions')
  170. title('Latent Variables Correlation')
  172. subplot(1, 3, 3)
  173. for l = 1:size(L, 2)
  174. plot(L(:, l) + ones(size(L, 1), 1) * 2 * l)
  175. hold on
  176. end
  177. title('Latent Variables Temporal Evolution')
  178. sgtitle('Generated Real Latent Variables Statistics')
  179. end
  181. % Orthogonalize latent variables using PCA (Principal Component Analysis)
  182. [~, L, ~] = pca(L, 'NumComponents', num_latent);
  183. L = zscore(L); % Z-score after PCA
  185. % Apply decay factor to scale latent variables
  186. SF = exp(-decayFactor * [1:num_latent]); % following a exponential decay
  187. % SF = [1:num_latent] .^ (-decayFactor); % following a power law function
  189. SF = SF / sum(SF); % Normalize scaling factors
  190. for i = 1:num_latent
  191. L(:, i) = L(:, i) * SF(i);
  192. end
  194. if display
  195. % Plot statistics of latent variables AFTER orthogonalization and scaling
  196. figure
  197. subplot(1, 3, 1)
  198. bar(var(L))
  199. ylabel('Variance')
  200. xlabel('Dimensions')
  201. title('Latent Variables Variance')
  203. subplot(1, 3, 2)
  204. imagesc(corr(L))
  205. ylabel('Dimensions')
  206. xlabel('Dimensions')
  207. title('Latent Variables Correlation')
  209. subplot(1, 3, 3)
  210. for l = 1:size(L, 2)
  211. plot(L(:, l) + ones(size(L, 1), 1) * l)
  212. hold on
  213. end
  214. title('Latent Variables Temporal Evolution (After Scaling)')
  215. sgtitle('Generated Real Latent Variables Statistics AFTER Scaling')
  216. end
  218. % Generate random weight matrix W
  219. W = normrnd(0, 1, num_latent, fake_units); %Draw samples from independent Guassian distributions to avoid directional biases
  221. % Normalize the weight matrix
  222. W = W ./ sqrt(sum(W.^2)); % Normalize the columns to have unit norm
  224. % Create 'U' matrix by combining real_latents with W
  225. U = L * W;
  227. % Add non-linearities if required
  228. if settings.nonLinAlfa > 0
  229. U = normalize(U,"range", [0 1]); % To be comparable with Altan et al. (2021) procedure
  230. U = (exp(settings.nonLinAlfa*U)-1) / (exp(settings.nonLinAlfa)-1);
  231. end
  233. % Generate noise matrix
  234. switch settings.noiseDistr
  235. case 'poisson'
  236. U = normalize(U,"range", [0 5]); %assuming a 50ms bin, it would correspond to a maximum FR around 100 sp/sec
  237. noise_matrix = poissrnd(U) - U; % Generate Poisson noise where each element's variance equals its value in U (subtract U since each generated element is expected to be equal to U)
  239. case 'gaussian'
  240. noise_matrix = normrnd(0, 1, size(U));
  241. end
  243. U = zscore(U); % Z-score 'U' matrix
  244. noise_matrix = zscore(noise_matrix); % Z-score the noise matrix
  246. % Adjust noise factor
  247. noiseFactor = noiseFactor * mean(std(U)./std(noise_matrix)); % Equilibrate noise and signal variances if not already equilibrated
  248. noise_matrix = noiseFactor * noise_matrix;
  250. % Apply different noise distribution depending on equalNoise flag
  251. if equalNoise
  252. beta = ones(1, fake_units)*0.5; % Equal noise distribution across all units
  253. else
  254. beta = normrnd(0.5, 1/6, 1, fake_units);
  255. beta(beta < 0) = 0; beta(beta > 1) = 1; % Clip values to [0, 1]
  256. end
  258. % Add noise to the data matrix X
  259. X = U .* (1 - beta) + noise_matrix .* beta; % Weighted noise addition
  260. X = X + abs(min(X)); % Ensure that all values in X are non-negative (firing rate)
  262. % Apply normalization if specified
  263. if soft_norm
  264. X = soft_normalize(X, 2, mean(X, 'all')/2);
  265. X = X - mean(X); % Center the data
  266. else
  267. X = zscore(X); % Standard z-score normalization
  268. end
  270. if display
  271. % Visualize the final simulated data matrix
  272. figure
  273. subplot(1, 2, 1)
  274. imagesc(X)
  275. colormap('hot')
  276. colorbar
  277. caxis([-3 3])
  279. subplot(1, 2, 2)
  280. for l = 1:3
  281. plot(X(:, randi(fake_units, 1, 1)) + ones(size(L, 1), 1) * 3 * l, 'LineWidth', 2)
  282. hold on
  283. end
  284. sgtitle('Simulated Fake Units')
  285. end
  287. % Estimate the latent variables' contribution to the data matrix X
  288. b = L \ X; % Solve the linear system X = real_latents * b
  290. % Calculate variance explained by each latent variable
  291. single_L_var = [];
  292. for i = 1:num_latent
  293. single_L_var(i) = 100 - (var(X - L(:, i) * b(i, :)) / var(X)) * 100;
  294. end
  295. [single_L_var, I] = sort(single_L_var, 'descend'); % Sort by variance explained
  297. L_R2s = [];
  298. for i = 1:num_latent
  299. L_R2s(i) = Rsquared(X, L(:, 1:i) * b(1:i, :));
  300. end
  302. L_var = 100 - (var(X - L * b) / var(X)) * 100;
  304. % Calculate how much the dataset is non-linear
  305. Xhat = [];
  306. for j = 1:fake_units
  307. b = U(:,j) \ X(:,j);
  308. Xhat = [Xhat, U(:,j)*b];
  309. end
  310. U_var = 100 - var(X - Xhat)/var(X)*100;
  312. nonLinear_var = U_var - L_var;
  314. % Calculate how much of the dataset is noise
  315. Xhat = [];
  316. for j = 1:fake_units
  317. b = noise_matrix(:,j) \ X(:,j);
  318. Xhat = [Xhat, noise_matrix(:,j)*b];
  319. end
  320. noise_var = 100 - var(X - Xhat)/var(X)*100; % Calculate the real noise variance percentage
  322. % calculate tau on X
  323. [tau, ~] = fit_tau(X, false);
  325. % Perform PCA on the final data matrix X
  326. [coeff, last_score, latent, tsquared, score_var, mu] = pca(X);
  327. score_var = score_var'; % Variance explained by each principal component
  328. if numel(score_var) < fake_units
  329. score_var = [score_var zeros(1, fake_units-numel(score_var))];
  330. end
  332. if display
  333. % Plot the variance explained by real latent variables vs PCs
  334. figure
  335. bar([single_L_var, zeros(1, fake_units - num_latent); score_var]')
  336. ylabel('Explained Variance')
  337. hold on
  338. yyaxis right
  339. plot(cumsum(single_L_var)) % Cumulative explained variance for real latent variables
  340. plot(cumsum(score_var)) % Cumulative explained variance for PCs
  341. legend('True Latent Variance', 'PCs Variance', 'True Latent Variance Cumsum', 'PCs Variance Cumsum')
  342. xlabel('Dimensions')
  343. ylabel('Total Explained Variance')
  344. title(['Data underlying linear structure / linearities = ' num2str(L_var) ...
  345. ' + nonlinearities = ' num2str(nonLinear_var) ...
  346. ' + noise = ' num2str(noise_var) '% of the X variance'])
  347. end
  349. % --- Return the outputs in a struct ---
  350. output.single_L_var = single_L_var;
  351. jj = min([num_latent fake_units]);
  352. output.single_L_SNR = single_L_var(1:jj)./score_var(1:jj);
  353. output.L_R2s = [L_R2s];
  354. output.L_var = L_var;
  355. output.U_var = U_var;
  356. output.noise_var = noise_var;
  357. output.nonLinear_var= nonLinear_var;
  358. output.L = L;
  359. output.U = U;
  360. output.noise_matrix = noise_matrix;
  361. output.tau = tau;
  362. output.settings = settings;
  363. output.fake_units = fake_units;
  364. output.time_series_length = time_series_length;
  365. output.num_latent = num_latent;
  367. end
  368. end

simulate_data_matrix.m at commit 5b6fb50, under MIT · at the source

Overview

Authors: Francesco Edoardo Vaccari1, Stefano Diomedi2, Edoardo Bettazzi1, Matteo Filippini1, Marina De Vitis1, Kostas Hadjidimitrakis1, Patrizia Fattori1,3
  1. Department of Biomedical and Neuromotor Sciences, University of Bologna,Bologna, Italy
  2. Institute of Cognitive Sciences and Technologies, National Research Council,Rome, Italy
  3. Alma Mater Research Institute for Human-Centered Artificial Intelligence, University of Bologna,Bologna, Italy
Institutions: University of Bologna (Italy); Institute of Cognitive Sciences and Technologies (Italy)
Journal: Scientific reports, volume 16, issue 1, article 26011
Dates: received 25 November 2025; accepted 22 May 2026; published online 8 June 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41598-026-55225-1 · PMID 42259857 · PMCID PMC13486701 · OpenAlex W7163877229
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: computational modeling (no new data) (modality), methods / tools (subfield)
Methods: Smoothing, state filtering, decompositions, Machine learning, Statistics, Preprocessing, Single-unit activity, calcium imaging, Physiology & signal measures, Spectral & time-frequency
Keywords: Dimensionality reduction, Principal components analysis (PCA), Latent variables, Simulations, Neural data analysis, Computational biology and bioinformatics, Neuroscience
MeSH: Benchmarking*, Neurons*, Primary Visual Cortex*, Algorithms, Animals, Computer Simulation, Dimensionality Reduction, Principal Component Analysis (* major topic)
Topic: Face Recognition and Perception (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: NextGenerationEU (PE0000006); Ministero dell'Università e della Ricerca (PRIN2022-2022BK2NPS); Ministero dell’Istruzione, dell’Università e della Ricerca (PNC0000007)
Citations: not cited yet (Europe PMC); 88 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

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

francescovaccari/Dimensionality-estimation

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 5b6fb5054f40222b3ed981df73040a50a2081297, 26 September 2025
Languages: MATLAB (16)
Size: 19 files, 16 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Statistics and Machine Learning Toolbox (6 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
18 files
At the source: github.com/francescovaccari/Dimensionality-estimation

francescovaccari/Dimensionality-estimation-upper-bound

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 230df0f1d77e6cef2960ec603a3cdd5c64368310, 26 March 2026
Languages: Python (3)
Size: 10 files, 3 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (requirements.txt, .devcontainer/devcontainer.json)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: pandas (2 files), Plotly (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
5 files
At the source: github.com/francescovaccari/Dimensionality-estimation-upper-bound

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41598-026-55225-1.

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 19 scripts, each with its path and the digest of its content;
  • 19 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

Datasets cited

Data availability statement

The paper has a data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s41598-026-55225-1.

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, 7 authors, 7 keywords, 8 MeSH terms, 3 funders, 83 references.

Cite

This paper

Vaccari, F. E., Diomedi, S., Bettazzi, E., Filippini, M., De Vitis, M., Hadjidimitrakis, K., & Fattori, P. (2026). Benchmarking criteria to determine latent linear dimensionality in neural data. Scientific reports, 16(1), 26011. https://doi.org/10.1038/s41598-026-55225-1

BibTeX

@article{vaccari2026benchmarking,
author = {Vaccari, Francesco Edoardo and Diomedi, Stefano and Bettazzi, Edoardo and Filippini, Matteo and De Vitis, Marina and Hadjidimitrakis, Kostas and Fattori, Patrizia},
title = {{Benchmarking criteria to determine latent linear dimensionality in neural data}},
journal = {Scientific reports},
year = {2026},
month = jun,
volume = {16},
number = {1},
pages = {26011},
publisher = {Nature Publishing Group},
issn = {2045-2322},
doi = {10.1038/s41598-026-55225-1},
url = {https://doi.org/10.1038/s41598-026-55225-1},
pmid = {42259857},
pmcid = {PMC13486701}
}

RIS

TY - JOUR
AU - Vaccari, Francesco Edoardo
AU - Diomedi, Stefano
AU - Bettazzi, Edoardo
AU - Filippini, Matteo
AU - De Vitis, Marina
AU - Hadjidimitrakis, Kostas
AU - Fattori, Patrizia
TI - Benchmarking criteria to determine latent linear dimensionality in neural data
T2 - Scientific reports
J2 - Sci Rep
PY - 2026
DA - 2026/06/08
VL - 16
IS - 1
SP - 26011
SN - 2045-2322
PB - Nature Publishing Group
DO - 10.1038/s41598-026-55225-1
UR - https://doi.org/10.1038/s41598-026-55225-1
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41598-026-55225-1",
"type": "article-journal",
"title": "Benchmarking criteria to determine latent linear dimensionality in neural data",
"container-title": "Scientific reports",
"author": [
{
"family": "Vaccari",
"given": "Francesco Edoardo"
},
{
"family": "Diomedi",
"given": "Stefano"
},
{
"family": "Bettazzi",
"given": "Edoardo"
},
{
"family": "Filippini",
"given": "Matteo"
},
{
"family": "De Vitis",
"given": "Marina"
},
{
"family": "Hadjidimitrakis",
"given": "Kostas"
},
{
"family": "Fattori",
"given": "Patrizia"
}
],
"container-title-short": "Sci Rep",
"volume": "16",
"issue": "1",
"page": "26011",
"DOI": "10.1038/s41598-026-55225-1",
"PMID": "42259857",
"PMCID": "PMC13486701",
"ISSN": "2045-2322",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41598-026-55225-1",
"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.neuron.2026.07.016 [code]
Inferring brain-wide interactions using data-constrained recurrent neural network models.
Journal: Neuron
In common: Statistics and Machine Learning Toolbox, computational modeling (no new data), 12 references
[2] doi:10.1038/s41467-026-71725-0 [code]
Interactions across hemispheres in prefrontal cortex reflect global cognitive processing.
Journal: Nature communications
In common: Statistics and Machine Learning Toolbox, pandas, 11 references
[3] doi:10.1371/journal.pcbi.1014162 [code]
Exploring neural manifolds across a wide range of intrinsic dimensions.
Journal: PLoS computational biology
In common: pandas, 9 references
[4] doi:10.1080/26941899.2026.2619222
Neurodatascience: Past, Present, and Future.
Journal: Data science in science
In common: 9 references
[5] doi:10.1038/s41467-026-75347-4 [code]
Sleep reveals dynamics integrating and segregating movement and stimulus representations in V1.
Journal: Nature communications
In common: Statistics and Machine Learning Toolbox, pandas, 7 references
[6] doi:10.1016/j.isci.2026.116780
The representational geometry of naturalistic textures in macaque V1 and V2.
Journal: iScience
In common: 7 references
[7] doi:10.1038/s42003-026-10036-y
Drifting population dynamics with transient resets characterize sensorimotor transformation in the monkey superior colliculus.
Journal: Communications biology
In common: 7 references
[8] doi:10.1371/journal.pcbi.1014719 [code]
Manifold-constrained plasticity enables stable learning in recurrent neural circuits.
Journal: PLoS computational biology
In common: 7 references
[9] doi:10.1093/nsr/nwag420 [code]
Constructing mesoscale functionomics by neural dynamics subspace clustering.
Journal: National science review
In common: Statistics and Machine Learning Toolbox, 6 references
[10] doi:10.1038/s41467-026-75455-1 [code]
Shared latent representations of speech production for cross-patient speech decoding.
Journal: Nature communications
In common: Plotly, Statistics and Machine Learning Toolbox, pandas, 4 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.