OSCR

DeepFaceMouse enables scalable prediction of large-scale brain activity from facial dynamics in mice.

Code ↔ Paper

5 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 5 matches
  1. [1] § STAR★Methods › Method details › Brain activity prediction using custom Deep Learning Model ↔ FaceBrainPredictionGUI_DeepFace_6s_6f.m, lines 509–580 · score 0.68 · auto regressive, processed brain, brain features, vector, linearly, filter
  2. [2] § STAR★Methods › Method details › Brain activity prediction using custom Deep Learning Model ↔ FaceBrainPredictionGUI_Facemap_8m_100Hz.m, lines 269–314 · score 0.63 · velocity features, raw feature, window aggregation, frame, Facemap, prediction
  3. [3] § STAR★Methods › Method details › Brain activity prediction using custom Deep Learning Model ↔ FaceBrainPredictionGUI_Facemap_6s_6f.m, lines 379–421 · score 0.62 · velocity features, raw feature, window aggregation, frame, Facemap, prediction
  4. [4] § STAR★Methods › Method details › Brain activity prediction using custom Deep Learning Model ↔ FaceBrainPredictionGUI_Facemap_6s_6f.m, lines 634–721 · score 0.60 · eye features, mouth features, centroid, nose, dynamic, prediction
  5. [5] § STAR★Methods › Method details › Brain activity prediction using custom Deep Learning Model ↔ FaceBrainPredictionGUI_Facemap_6s_6f.m, lines 1–44 · score 0.57 · corresponding brain, face brain, hemodynamic, FaceMap, Facial, tracking

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 · 736 lines · 29 KB · CC-BY-4.0 · 3 matches

  1. function FaceBrainPredictionGUI_Facemap_NoEnsemble_winsorizedR2_ko
  2. % FaceBrainPredictionGUI_Facemap_NoEnsemble_winsorizedR2.m
  3. %
  4. % Overview:
  6. %
  7. % The GUI includes the following functionalities:
  8. % 1. Set Data Label: Specify a label for the dataset.
  9. % 2. Change Save Folder: Select a folder to save outputs, models, graphs, and test data.
  10. % 3. Add Training Pairs: Select face CSV and corresponding brain MAT files for training.
  11. % 4. Clear Training Pairs: Remove current training data from memory.
  12. % 5. Add Testing Pairs: Select face CSV and corresponding brain MAT files for testing.
  13. % 6. Clear Testing Pairs: Remove current testing data from memory.
  14. % 7. Clear In-Memory Model: Reset the current model.
  15. % 8. Load Pre-Trained Model: Load a previously saved model (Neural Network or Ensemble).
  16. % 9. Train New Model: Train a new Neural Network model using the training pairs.
  17. % 10. Test Model: Run the model on testing pairs. For each test pair:
  18. % - Computes performance metrics: RMSE, standard R², Winsorized R² (Filtered R²), and MAE.
  19. % - Generates a figure comparing actual and predicted signals.
  20. % - Saves the figure as both .fig and .png files.
  21. % - Saves test data and metrics in a .mat file.
  22. % - Writes overall test metrics to an Excel file.
  23. % 11. Save Pairs to Disk: Save current training/testing pairs to a .mat backup file.
  24. % 12. Load Pairs from Disk: Load training/testing pairs from a backup file.
  25. % 13. Exit: Exit the application.
  26. %
  27. % Instructions for New Users:
  28. % - Prepare your face data as CSV files that include columns for tracking facial features.
  29. % - Prepare your brain data as MAT files containing a variable with hemodynamic signals.
  30. % The script automatically detects the relevant field (e.g., 'hemodynamic').
  31. % - Follow the menu options to add training/testing pairs.
  32. % - Train your model and then test it; the script will generate and save graphs and metrics.
  33. %
  34. % Outputs:
  35. % - Trained model saved as a .mat file.
  36. % - Test graphs saved as .fig and .png files.
  37. % - Test data and metrics saved as individual .mat files.
  38. % - An Excel file summarizing test metrics.
  39. %
  40. % Note:
  41. % - The Winsorized R² (Filtered R²) calculation ignores the top 5% of errors to
  42. % reduce the impact of outliers.
  44. clc; clear;
  46. %% Default Parameters
  47. dataLabel = 'withaddbrain';
  48. savePath = pwd; % Default: current folder
  49. fsBrain = 20; % Brain sampling rate (Hz)
  50. fsFace = 120; % Face sampling rate (Hz)
  51. bandpassLowCut = 0.1; % For brain band-pass filtering
  52. bandpassHighCut = 9.99;
  53. butterOrder = 2;
  54. movAvgBrainSec = 1; % 1 s moving average for brain smoothing
  55. ignoreInitialSec = 5; % Ignore first 5 s of both signals
  56. faceWindowSize = 5; % Number of face frames per time-window aggregator
  57. nnHiddenNeurons = 5;
  58. nnEpochs = 100;
  59. % ensLearningCycles = 50; % Not used
  61. % Filenames for saving test metrics and pairs backup
  62. testMetricsFile = 'TestMetrics.xlsx';
  63. pairsBackupFile = [dataLabel '_pairsBackup.mat'];
  65. %% Data in Memory
  66. trainingPairs = [];
  67. testingPairs = [];
  69. %% Model
  70. currentModel = [];
  71. currentModelType = ''; % 'Neural Network' or 'Ensemble'
  73. %% Main Menu Loop
  74. while true
  75. choice = menu('Select an option', ...
  76. '1. Set Data Label', ...
  77. '2. Change Save Folder', ...
  78. '3. Add Training Pairs (Face CSV + Brain MAT)', ...
  79. '4. Clear Training Pairs', ...
  80. '5. Add Testing Pairs (Face CSV + Brain MAT)', ...
  81. '6. Clear Testing Pairs', ...
  82. '7. Clear In-Memory Model', ...
  83. '8. Load Pre-Trained Model', ...
  84. '9. Train New Model', ...
  85. '10. Test Model', ...
  86. '11. Save Pairs to Disk', ...
  87. '12. Load Pairs from Disk', ...
  88. '13. Exit');
  90. switch choice
  91. case 1
  92. prompt = {'Enter data label (e.g. withaddbrain):'};
  93. dlg_title = 'Set Data Label';
  94. answer = inputdlg(prompt, dlg_title, 1, {dataLabel});
  95. if ~isempty(answer)
  96. dataLabel = answer{1};
  97. fprintf('Data label set to: %s\n', dataLabel);
  98. end
  100. case 2
  101. newFolder = uigetdir([], 'Select folder for saving outputs/models');
  102. if isequal(newFolder, 0)
  103. disp('No folder selected. Save folder unchanged.');
  104. else
  105. savePath = newFolder;
  106. fprintf('Save folder changed to: %s\n', savePath);
  107. end
  109. case 3
  110. addMultipleBrainPairs('training', fsFace, fsBrain, faceWindowSize, ...
  111. bandpassLowCut, bandpassHighCut, butterOrder, movAvgBrainSec, ignoreInitialSec);
  113. case 4
  114. trainingPairs = [];
  115. disp('Training pairs cleared.');
  117. case 5
  118. addMultipleBrainPairs('testing', fsFace, fsBrain, faceWindowSize, ...
  119. bandpassLowCut, bandpassHighCut, butterOrder, movAvgBrainSec, ignoreInitialSec);
  121. case 6
  122. testingPairs = [];
  123. disp('Testing pairs cleared.');
  125. case 7
  126. currentModel = [];
  127. currentModelType = '';
  128. disp('Cleared in-memory model.');
  130. case 8
  131. [modelFile, modelPath] = uigetfile('*.mat','Select a pre-trained model file');
  132. if isequal(modelFile, 0)
  133. disp('No model file selected.');
  134. else
  135. loadedData = load(fullfile(modelPath, modelFile));
  136. modelTypeChoice = menu('Select model type','Neural Network','Ensemble');
  137. if modelTypeChoice == 1
  138. if isfield(loadedData, 'net')
  139. currentModel = loadedData.net;
  140. currentModelType = 'Neural Network';
  141. fprintf('Loaded Neural Network model from: %s\n', modelFile);
  142. else
  143. error('The file does not contain variable "net".');
  144. end
  145. else
  146. if isfield(loadedData, 'ensModel')
  147. currentModel = loadedData.ensModel;
  148. currentModelType = 'Ensemble';
  149. fprintf('Loaded Ensemble model from: %s\n', modelFile);
  150. else
  151. error('The file does not contain variable "ensModel".');
  152. end
  153. end
  154. end
  156. case 9
  157. % Train new model
  158. if isempty(trainingPairs)
  159. disp('No training pairs available.');
  160. continue;
  161. end
  162. [Xall, Yall] = concatPairs(trainingPairs);
  163. if isempty(Xall)
  164. disp('No valid data in training pairs.');
  165. continue;
  166. end
  167. % Train only the Neural Network model
  168. net = fitnet(nnHiddenNeurons);
  169. net.trainParam.epochs = nnEpochs;
  170. net.trainParam.goal = 1e-4;
  171. [net, ~] = train(net, Xall', Yall');
  172. YpredNN = net(Xall');
  173. rmseNN = sqrt(mean((YpredNN' - Yall).^2));
  174. r2NN = 1 - sum((Yall - YpredNN').^2) / sum((Yall - mean(Yall)).^2);
  175. fprintf('Neural Net: RMSE=%.4f, R^2=%.4f\n', rmseNN, r2NN);
  177. % Set neural network as the current model
  178. currentModel = net;
  179. currentModelType = 'Neural Network';
  181. % Save neural network model
  182. save(fullfile(savePath, [dataLabel '_trainedNeuralNetwork.mat']), 'net');
  183. disp('Neural Network model saved to disk.');
  185. case 10
  186. % Test Model
  187. if isempty(testingPairs)
  188. disp('No testing pairs available.');
  189. continue;
  190. end
  191. if isempty(currentModel)
  192. disp('No model loaded/trained. Please train or load a model first.');
  193. continue;
  194. end
  196. % Debug messages
  197. disp('Entering Test Model mode...');
  198. fprintf('Number of testing pairs: %d\n', length(testingPairs));
  200. testRMSEs = [];
  201. testR2s = [];
  202. testFilteredR2s = [];
  203. testMAEs = [];
  204. metricsCell = {}; % {BrainFile, Region, Hemisphere, RMSE, R2, Filtered R^2, MAE}
  206. for iPair = 1:length(testingPairs)
  207. fprintf('Processing test pair %d of %d...\n', iPair, length(testingPairs));
  208. Xtest = testingPairs(iPair).X;
  209. Ytest = testingPairs(iPair).Y;
  211. if strcmpi(currentModelType, 'Neural Network')
  212. Ypred = currentModel(Xtest')';
  213. else
  214. Ypred = predict(currentModel, Xtest);
  215. end
  217. if length(Ypred) == length(Ytest)
  218. rmseVal = sqrt(mean((Ypred - Ytest).^2));
  219. r2Val = 1 - sum((Ytest - Ypred).^2) / sum((Ytest - mean(Ytest)).^2);
  220. else
  221. minLen = min(length(Ypred), length(Ytest));
  222. rmseVal = sqrt(mean((Ypred(1:minLen) - Ytest(1:minLen)).^2));
  223. r2Val = NaN;
  224. end
  226. % Compute Winsorized R² (Filtered R²)
  227. errorValues = abs(Ytest - Ypred);
  228. threshold = prctile(errorValues, 99); % Ignore top 1% of errors
  229. validIdx = errorValues < threshold;
  230. r2Filtered = 1 - sum((Ytest(validIdx) - Ypred(validIdx)).^2) / sum((Ytest(validIdx) - mean(Ytest(validIdx))).^2);
  232. % Compute MAE (Mean Absolute Error)
  233. maeVal = mean(abs(Ytest - Ypred));
  235. testRMSEs(end+1) = rmseVal;
  236. testR2s(end+1) = r2Val;
  237. testFilteredR2s(end+1) = r2Filtered;
  238. testMAEs(end+1) = maeVal;
  240. regionStr = testingPairs(iPair).region;
  241. hemisphereStr = testingPairs(iPair).hemisphere;
  242. brainFile = testingPairs(iPair).brainMAT;
  243. fprintf('Test Pair %d\n Face: %s\n Brain: %s\n Region: %s, Hemi: %s\n', ...
  244. iPair, testingPairs(iPair).faceCSV, brainFile, regionStr, hemisphereStr);
  245. fprintf(' RMSE=%.4f, R^2=%.4f, Filtered R^2=%.4f, MAE=%.4f\n', rmseVal, r2Val, r2Filtered, maeVal);
  247. % Save metrics for this test pair
  248. metricsCell(iPair, :) = {brainFile, regionStr, hemisphereStr, rmseVal, r2Val, r2Filtered, maeVal};
  250. % Generate the prediction figure and save as .fig and .png
  251. fig = figure('Visible','off','Position',[100 100 1000 600]);
  252. plot(Ytest, 'g', 'LineWidth', 1.2); hold on;
  253. plot(Ypred, 'r', 'LineWidth', 1.2);
  254. legend('Actual Brain', 'Predicted', 'Location', 'best');
  255. title(sprintf('Brain main(t) Prediction (Auto-Regressive Input)\nRMSE=%.4f, R^2=%.4f', rmseVal, r2Val));
  256. xlabel('Samples'); ylabel('Amplitude');
  257. [~, bName, ~] = fileparts(brainFile);
  258. pngName = sprintf('TestPair%d_%s.png', iPair, bName);
  259. figName = sprintf('TestPair%d_%s.fig', iPair, bName);
  260. savefig(fig, fullfile(savePath, figName));
  261. saveas(fig, fullfile(savePath, pngName));
  262. % Save test data and figure info in .mat file
  263. matFileName = fullfile(savePath, sprintf('TestPair%d_%s.mat', iPair, bName));
  264. save(matFileName, 'Ytest', 'Ypred', 'brainFile', 'regionStr', 'hemisphereStr', 'rmseVal', 'r2Val');
  265. close(fig);
  266. end
  268. if ~isempty(testRMSEs)
  269. avgRMSE = mean(testRMSEs);
  270. avgR2 = mean(testR2s);
  271. fprintf('---\nOverall Test RMSE=%.4f, R^2=%.4f\n', avgRMSE, avgR2);
  272. end
  274. header = {'BrainFile', 'Region', 'Hemisphere', 'RMSE', 'R2', 'Filtered R^2', 'MAE'};
  275. if ~isempty(metricsCell)
  276. outCell = [header; metricsCell];
  277. else
  278. outCell = header;
  279. end
  281. outFile = fullfile(savePath, testMetricsFile);
  282. writecell(outCell, outFile, 'Sheet', 'TestMetrics', 'Range', 'A1');
  283. fprintf('Wrote test metrics to %s\n', outFile);
  285. case 11
  286. % Save pairs to disk
  287. pairsFile = fullfile(savePath, pairsBackupFile);
  288. save(pairsFile, 'trainingPairs', 'testingPairs');
  289. fprintf('Saved pairs to %s\n', pairsFile);
  291. case 12
  292. % Load pairs from disk
  293. pairsFile = fullfile(savePath, pairsBackupFile);
  294. if exist(pairsFile, 'file')
  295. load(pairsFile, 'trainingPairs', 'testingPairs');
  296. fprintf('Loaded pairs from %s\n', pairsFile);
  297. fprintf('Training pairs: %d, Testing pairs: %d\n', numel(trainingPairs), numel(testingPairs));
  298. else
  299. fprintf('No backup file found at %s\n', pairsFile);
  300. end
  302. case 13
  303. disp('Exiting application.');
  304. break;
  305. end
  306. end
  308. %% Nested Functions
  310. function addMultipleBrainPairs(modeStr, fsFace, fsBrain, faceWindowSize, bandpassLowCut, bandpassHighCut, bOrder, movAvgBrainSec, ignoreSec)
  311. [faceFile, facePath] = uigetfile('*.csv', sprintf('Select Face CSV (%.0f Hz) for %s', fsFace, modeStr));
  312. if isequal(faceFile, 0)
  313. disp('No face CSV selected.');
  314. return;
  315. end
  316. faceFullPath = fullfile(facePath, faceFile);
  318. [brainFiles, brainPath] = uigetfile('*.mat', sprintf('Select Brain MAT(s) (%.0f Hz) for %s', fsBrain, modeStr), 'MultiSelect', 'on');
  319. if isequal(brainFiles, 0)
  320. disp('No brain MAT selected.');
  321. return;
  322. end
  323. if ischar(brainFiles)
  324. brainFiles = {brainFiles};
  325. end
  327. % Load and aggregate face data using a time-window approach and z-scoring
  328. [faceTime, faceDataWindowed] = loadFaceCSV_withAggregatesWindowed(faceFullPath, fsFace, faceWindowSize);
  329. if isempty(faceDataWindowed)
  330. warning('Face aggregator is empty for %s. Skipping pair addition.', faceFile);
  331. return;
  332. end
  334. for iB = 1:length(brainFiles)
  335. brainFullPath = fullfile(brainPath, brainFiles{iB});
  337. % Load brain data and compute additional derived features
  338. [brainTime, brainMain, optionalBrainFeats] = loadBrainMAT_andDerived(brainFullPath, fsBrain);
  340. % Align and construct the final input and target.
  341. [Xaligned, Yaligned] = alignAndConstructAutoReg(faceTime, faceDataWindowed, fsFace, ...
  342. brainTime, brainMain, optionalBrainFeats, fsBrain, ...
  343. bandpassLowCut, bandpassHighCut, bOrder, ...
  344. movAvgBrainSec, ignoreSec);
  346. % Skip pair if Xaligned is empty or has inconsistent columns.
  347. if isempty(Xaligned) || size(Xaligned,2) == 0 || isempty(Yaligned)
  348. fprintf('Skipping pair for Brain file: %s due to insufficient data.\n', brainFiles{iB});
  349. continue;
  350. end
  352. newPair.faceCSV = faceFullPath;
  353. newPair.brainMAT = brainFullPath;
  354. % Parse region and hemisphere from file name (simple heuristic)
  355. [~, baseName, ~] = fileparts(brainFullPath);
  356. tokens = regexp(baseName, '^(.*?)(bilateral|left|right)', 'tokens', 'once');
  357. if ~isempty(tokens)
  358. regionStr = regexprep(tokens{1}, '_$', '');
  359. hemisphereStr = tokens{2};
  360. else
  361. regionStr = baseName;
  362. hemisphereStr = 'unknown';
  363. end
  364. newPair.region = regionStr;
  365. newPair.hemisphere = hemisphereStr;
  366. newPair.X = Xaligned;
  367. newPair.Y = Yaligned;
  369. if strcmpi(modeStr, 'training')
  370. trainingPairs = [trainingPairs; newPair];
  371. fprintf('Added to TRAINING: Face=%s, Brain=%s\n', faceFile, brainFiles{iB});
  372. else
  373. testingPairs = [testingPairs; newPair];
  374. fprintf('Added to TESTING: Face=%s, Brain=%s\n', faceFile, brainFiles{iB});
  375. end
  376. end
  377. end
  379. function [faceTimeOut, faceDataWindowed] = loadFaceCSV_withAggregatesWindowed(csvFile, fsFace, windowSize)
  380. opts = detectImportOptions(csvFile, 'VariableNamingRule', 'preserve');
  381. T = readtable(csvFile, opts);
  383. % Remove columns with "score" and "track"
  384. scoreMask = contains(T.Properties.VariableNames, 'score', 'IgnoreCase', true);
  385. T(:, scoreMask) = [];
  386. if ismember('track', T.Properties.VariableNames)
  387. T = removevars(T, 'track');
  388. end
  390. % Find frame column among 'Frame','frame','frame_idx'
  391. possibleFrames = {'Frame', 'frame', 'frame_idx'};
  392. colFound = intersect(possibleFrames, T.Properties.VariableNames, 'stable');
  393. if ~isempty(colFound)
  394. frameVec = T.(colFound{1});
  395. T = removevars(T, colFound{1});
  396. else
  397. if width(T) < 2
  398. error('No recognized frame column.');
  399. end
  400. frameVec = T{:,2};
  401. T(:,2) = [];
  402. end
  403. faceTime = (frameVec - frameVec(1)) / fsFace;
  405. % Compute aggregator features and velocities
  406. rawFeatures = computeAggregateFeatures(T); % Nx12
  407. velFeatures = computeVelocities(rawFeatures, fsFace); % Nx12 => total Nx24
  408. allFeatures = [rawFeatures, velFeatures];
  410. [faceTimeU, idxU] = unique(faceTime, 'stable');
  411. allFeatures = allFeatures(idxU, :);
  412. faceTime = faceTimeU;
  414. [faceTimeClean, faceData] = cleanAndInterpolateFaceData(faceTime, allFeatures);
  416. % Z-score each column
  417. zFaceData = zscore(faceData, 0, 1);
  419. % Build time-window aggregator
  420. [faceTimeOut, faceDataWindowed] = buildTimeWindow(faceTimeClean, zFaceData, windowSize);
  421. end
  423. function [timeWin, dataWin] = buildTimeWindow(timeIn, dataIn, wSize)
  424. N = length(timeIn);
  425. c = size(dataIn, 2);
  426. outRows = N - wSize + 1;
  427. if outRows < 1
  428. warning('Not enough data for time-window aggregator. Returning empty.');
  429. timeWin = [];
  430. dataWin = [];
  431. return;
  432. end
  433. dataWin = zeros(outRows, c * wSize);
  434. timeWin = timeIn(wSize:end);
  435. for i = 1:outRows
  436. block = dataIn(i:i+wSize-1, :); % [wSize x c]
  437. dataWin(i, :) = block(:)'; % Flatten row-major
  438. end
  439. end
  441. function [brainTime, brainMain, optionalBrainFeats] = loadBrainMAT_andDerived(matFile, fsBrain)
  442. S = load(matFile);
  443. fieldNames = fieldnames(S);
  444. hemoField = '';
  445. for iF = 1:numel(fieldNames)
  446. if contains(fieldNames{iF}, 'hemodynamic', 'IgnoreCase', true) && ~contains(fieldNames{iF}, 'sub', 'IgnoreCase', true)
  447. hemoField = fieldNames{iF};
  448. break;
  449. end
  450. end
  451. if isempty(hemoField)
  452. % fallback: look for 'hemo'
  453. for iF = 1:numel(fieldNames)
  454. if contains(fieldNames{iF}, 'hemo', 'IgnoreCase', true)
  455. hemoField = fieldNames{iF};
  456. break;
  457. end
  458. end
  459. end
  460. if isempty(hemoField)
  461. error('No hemodynamic field found in %s.', matFile);
  462. end
  463. brainMain = S.(hemoField);
  464. if isfield(S, 'hemoTime')
  465. brainTime = S.hemoTime;
  466. elseif isfield(S, 'time')
  467. brainTime = S.time;
  468. else
  469. nSamples = length(brainMain);
  470. brainTime = (0:nSamples-1)' / fsBrain;
  471. end
  473. % If brainMain is multi-dimensional, use PCA to extract top 3 components.
  474. if size(brainMain, 2) > 1
  475. [~, score, ~] = pca(brainMain);
  476. optionalBrainFeats = score(:, 1:3);
  477. else
  478. % Otherwise, compute frequency-domain features using a 1-second window.
  479. optionalBrainFeats = computeBrainFreqFeatures(brainMain, fsBrain);
  480. % Interpolate to match length of brainMain if needed.
  481. if size(optionalBrainFeats, 1) < length(brainMain)
  482. tFreq = linspace(0, 1, size(optionalBrainFeats, 1))';
  483. tBrain = linspace(0, 1, length(brainMain))';
  484. optionalBrainFeats = interp1(tFreq, optionalBrainFeats, tBrain, 'linear', 'extrap');
  485. end
  486. end
  487. end
  489. function freqFeats = computeBrainFreqFeatures(brainSignal, fs)
  490. % Compute frequency-domain features using a 1-second window (fs samples)
  491. winSize = round(1 * fs); % 1-second window
  492. N = length(brainSignal);
  493. nOut = N - winSize + 1;
  494. freqFeats = zeros(nOut, 2); % 2 features: power in two bands
  495. for i = 1:nOut
  496. windowData = brainSignal(i:i+winSize-1);
  497. windowData = windowData .* hamming(winSize);
  498. X = fft(windowData);
  499. P2 = abs(X / winSize).^2;
  500. P1 = P2(1:floor(winSize/2)+1);
  501. f = (0:floor(winSize/2))' * (fs / winSize);
  502. % Define two bands: 0.1-0.5 Hz and 0.5-4 Hz (adjust if needed)
  503. idx1 = f >= 0.1 & f < 1;
  504. idx2 = f >= 1 & f <= 5;
  505. power1 = sum(P1(idx1));
  506. power2 = sum(P1(idx2));
  507. freqFeats(i, :) = [power1, power2];
  508. end
  509. end
  511. function [Xaligned, Yaligned] = alignAndConstructAutoReg(faceTime, faceDataWindowed, fsFace, ...
  512. brainTime, brainMainInput, optionalBrainFeats, fsBrain, lowCut, highCut, bOrder, movAvgBrainSec, ignoreSec)
  514. % 1) Band-pass filter, compute DF/F, smooth
  515. yFilt = bandpassFilter(brainMainInput, fsBrain, lowCut, highCut, bOrder);
  516. baseVal = mean(yFilt);
  517. yDFF = (yFilt / baseVal) - 1;
  518. windowBrain = round(movAvgBrainSec * fsBrain);
  519. yProc = smoothdata(yDFF, 'movmean', windowBrain);
  521. % 2) Remove initial ignoreSec from both face and brain
  522. faceSkip = round(ignoreSec * fsFace);
  523. if faceSkip < length(faceTime)
  524. faceTime(1:faceSkip) = [];
  525. faceDataWindowed(1:faceSkip, :) = [];
  526. else
  527. warning('Ignoring entire face signal? Check data length.');
  528. faceTime(faceSkip:end) = [];
  529. faceDataWindowed(faceSkip:end, :) = [];
  530. end
  531. brainSkip = round(ignoreSec * fsBrain);
  532. if brainSkip < length(brainTime)
  533. brainTime(1:brainSkip) = [];
  534. yProc(1:brainSkip) = [];
  535. if ~isempty(optionalBrainFeats)
  536. optionalBrainFeats(1:brainSkip, :) = [];
  537. end
  538. else
  539. warning('Ignoring entire brain signal? Check data length.');
  540. brainTime(brainSkip:end) = [];
  541. yProc(brainSkip:end) = [];
  542. if ~isempty(optionalBrainFeats)
  543. optionalBrainFeats(1:brainSkip) = [];
  544. end
  545. end
  547. % 3) Resample face aggregator onto brain time
  548. faceInterp = zeros(length(brainTime), size(faceDataWindowed, 2));
  549. for c = 1:size(faceDataWindowed, 2)
  550. faceInterp(:, c) = interp1(faceTime, faceDataWindowed(:, c), brainTime, 'linear', 'extrap');
  551. end
  553. % 4) Resample optional brain features (if any) onto same time
  554. if ~isempty(optionalBrainFeats)
  555. brainFeatsInterp = zeros(length(brainTime), size(optionalBrainFeats, 2));
  556. % We assume optionalBrainFeats covers 0..1 in normalized time
  557. tOptional = linspace(0, 1, size(optionalBrainFeats, 1))';
  558. tBrain = linspace(0, 1, length(brainTime))';
  559. for c = 1:size(optionalBrainFeats, 2)
  560. brainFeatsInterp(:, c) = interp1(tOptional, optionalBrainFeats(:, c), tBrain, 'linear', 'extrap');
  561. end
  562. else
  563. brainFeatsInterp = [];
  564. end
  566. % 5) Construct auto-reg input with BrainMain(t-1)
  567. yShift = [NaN; yProc(1:end-1)];
  568. idxValid = 2:length(yProc); % remove first sample
  569. Xface = faceInterp(idxValid, :);
  570. Yfinal = yProc(idxValid);
  571. yShiftValid = yShift(idxValid);
  573. if ~isempty(brainFeatsInterp)
  574. bFeats = brainFeatsInterp(idxValid, :);
  575. Xall = [Xface, bFeats, yShiftValid];
  576. else
  577. Xall = [Xface, yShiftValid];
  578. end
  580. Xaligned = Xall;
  581. Yaligned = Yfinal;
  582. end
  584. function y = bandpassFilter(x, fs, lowCut, highCut, order)
  585. nyq = fs / 2;
  586. [b, a] = butter(order, [lowCut, highCut] / nyq, 'bandpass');
  587. y = filtfilt(b, a, x);
  588. end
  590. function [Xall, Yall] = concatPairs(pairsStruct)
  591. Xall = [];
  592. Yall = [];
  593. for i = 1:length(pairsStruct)
  594. Xi = pairsStruct(i).X;
  595. Yi = pairsStruct(i).Y;
  596. if isempty(Xi) || isempty(Yi)
  597. fprintf('Pair %d is empty. Skipping.\n', i);
  598. continue;
  599. end
  600. if isempty(Xall)
  601. Xall = Xi;
  602. Yall = Yi;
  603. else
  604. if size(Xi, 2) ~= size(Xall, 2)
  605. fprintf('Pair %d has %d columns, expected %d. Skipping pair.\n', i, size(Xi,2), size(Xall,2));
  606. continue;
  607. end
  608. Xall = [Xall; Xi];
  609. Yall = [Yall; Yi];
  610. end
  611. end
  612. end
  614. function [faceTime, faceData] = cleanAndInterpolateFaceData(faceTimeIn, faceDataIn)
  615. cleanTime = faceTimeIn(:);
  616. cleanData = faceDataIn;
  617. badMask = ~isfinite(cleanTime);
  618. if any(badMask)
  619. cleanTime(badMask) = [];
  620. cleanData(badMask, :) = [];
  621. end
  622. [nr, nc] = size(cleanData);
  623. for c = 1:nc
  624. colVals = cleanData(:, c);
  625. invalidMask = (colVals == 0) | isnan(colVals) | isinf(colVals);
  626. colVals(invalidMask) = NaN;
  627. colVals = fillmissing(colVals, 'linear', 'EndValues', 'extrap');
  628. cleanData(:, c) = colVals;
  629. end
  630. faceTime = cleanTime;
  631. faceData = cleanData;
  632. end
  634. function aggFeatures = computeAggregateFeatures(T)
  635. % This function computes 12 aggregator features from face data table T.
  636. % Updated to handle the possibility that only 3 whisker points exist
  637. % instead of 4. It checks columns dynamically.
  639. % The 12 aggregator features are:
  640. % (1) eyeCentroid_x
  641. % (2) eyeCentroid_y
  642. % (3) eyeArea
  643. % (4) noseMid_x
  644. % (5) noseMid_y
  645. % (6) noseDist
  646. % (7) mouthMid_x
  647. % (8) mouthMid_y
  648. % (9) mouthDist
  649. % (10) whiskerCentroid_x
  650. % (11) whiskerCentroid_y
  651. % (12) whiskerSpread
  653. N = height(T);
  654. aggFeatures = zeros(N, 12);
  656. % Whisker columns that might exist:
  657. possibleWhiskers = {'Whisker_T_L', 'Whisker_T_R', 'Whisker_B_L', 'Whisker_B_R'};
  659. for i = 1:N
  660. %% Eye features (Top, Bottom, Left, Right)
  661. eX = [safeVal(T, i, 'Top.x'), safeVal(T, i, 'Bottom.x'), safeVal(T, i, 'Left.x'), safeVal(T, i, 'Right.x')];
  662. eY = [safeVal(T, i, 'Top.y'), safeVal(T, i, 'Bottom.y'), safeVal(T, i, 'Left.y'), safeVal(T, i, 'Right.y')];
  664. eyeCentroid_x = mean(eX);
  665. eyeCentroid_y = mean(eY);
  666. w = max(eX) - min(eX);
  667. h = max(eY) - min(eY);
  668. eyeArea = w * h;
  670. %% Nose features (Nose_Top, Nose_Bottom)
  671. nxTop = safeVal(T, i, 'Nose_Top.x');
  672. nyTop = safeVal(T, i, 'Nose_Top.y');
  673. nxBot = safeVal(T, i, 'Nose_Bottom.x');
  674. nyBot = safeVal(T, i, 'Nose_Bottom.y');
  676. noseMid_x = mean([nxTop, nxBot]);
  677. noseMid_y = mean([nyTop, nyBot]);
  678. noseDist = sqrt((nxBot - nxTop)^2 + (nyBot - nyTop)^2);
  680. %% Mouth features (Mouth_Top, Mouth_Bottom)
  681. mxTop = safeVal(T, i, 'Mouth_Top.x');
  682. myTop = safeVal(T, i, 'Mouth_Top.y');
  683. mxBot = safeVal(T, i, 'Mouth_Bottom.x');
  684. myBot = safeVal(T, i, 'Mouth_Bottom.y');
  686. mouthMid_x = mean([mxTop, mxBot]);
  687. mouthMid_y = mean([myTop, myBot]);
  688. mouthDist = sqrt((mxBot - mxTop)^2 + (myBot - myTop)^2);
  690. %% Whisker features
  691. whiskerXvals = [];
  692. whiskerYvals = [];
  693. for widx = 1:length(possibleWhiskers)
  694. baseLabel = possibleWhiskers{widx};
  695. xLabel = [baseLabel, '.x'];
  696. yLabel = [baseLabel, '.y'];
  697. if ismember(xLabel, T.Properties.VariableNames) && ismember(yLabel, T.Properties.VariableNames)
  698. wX = safeVal(T, i, xLabel);
  699. wY = safeVal(T, i, yLabel);
  700. if ~(wX == 0 && wY == 0)
  701. whiskerXvals(end+1) = wX;
  702. whiskerYvals(end+1) = wY;
  703. end
  704. end
  705. end
  707. if isempty(whiskerXvals)
  708. whiskerCentroid_x = 0;
  709. whiskerCentroid_y = 0;
  710. whiskerSpread = 0;
  711. else
  712. whiskerCentroid_x = mean(whiskerXvals);
  713. whiskerCentroid_y = mean(whiskerYvals);
  714. ww = max(whiskerXvals) - min(whiskerXvals);
  715. hh = max(whiskerYvals) - min(whiskerYvals);
  716. whiskerSpread = ww * hh;
  717. end
  719. aggFeatures(i, :) = [eyeCentroid_x, eyeCentroid_y, eyeArea, noseMid_x, noseMid_y, noseDist, mouthMid_x, mouthMid_y, mouthDist, whiskerCentroid_x, whiskerCentroid_y, whiskerSpread];
  720. end
  721. end
  723. function val = safeVal(T, row, colName)
  724. if ismember(colName, T.Properties.VariableNames)
  725. val = T.(colName)(row);
  726. else
  727. val = 0;
  728. end
  729. end
  731. function vel = computeVelocities(features, fs)
  732. vel = [zeros(1, size(features,2)); diff(features)] * fs;
  733. end
  735. end

FaceBrainPredictionGUI_Facemap_6s_6f.m, under CC-BY-4.0 · at the source

Overview

Authors: Kemal Ozdemirli1,2, Tenesha Connor1,3, Kaleb Kim1,4, Ersan Alp Unlu1,4, Macit Emre Lacin1, Miguel Maldonado1,4, Frederick Bell1,5, Thiago Peixoto Leal6, Caglar Oksuz4, Anthony Sloan7, Nicholas Sarn6, Anthony Chomyk1, Bruce Trapp1, Justin D Lathia7,8,9,10, Ignacio Mata6,11, Charis Eng6, Murat Yildirim1,8
ORCID iDs: Kemal Ozdemirli, Murat Yildirim
  1. Department of Neurosciences, Cleveland Clinic Research, Cleveland, OH, USA
  2. Department of Mechanical and Aerospace Engineering, Case Western Reserve University, Cleveland, OH, USA
  3. Department of Biomedical and Chemical Engineering, Cleveland State University, Cleveland, OH, USA
  4. Department of Computer and Data Sciences, Case Western Reserve University, Cleveland, OH, USA
  5. Department of Neurosciences, Case Western Reserve University, Cleveland, OH, USA
  6. Genomic Sciences and Systems Biology, Cleveland Clinic Research, Cleveland, OH, USA
  7. Department of Cancer Sciences, Cleveland Clinic Research, Cleveland, OH, USA
  8. Comprehensive Cancer Center, Case Western Reserve University, Cleveland, OH, USA
  9. Rose Ella Burkhardt Brain Tumor & Neuro-Oncology Center, Cleveland Clinic, Cleveland, OH, USA
  10. Department of Clinical Medicine, Faculty of Health and Medical Sciences, University of Copenhagen, Copenhagen, Denmark
  11. Department of Molecular Medicine, Case Western Reserve University, Cleveland, OH, USA
Institutions: Cleveland Clinic (United States); Case Western Reserve University (United States); Cleveland State University (United States); University of Copenhagen (Denmark); Case Comprehensive Cancer Center
Journal: Cell reports methods, volume 6, issue 8, article 101480
Dates: received 2 July 2025; accepted 8 May 2026; published online 8 June 2026; in print August 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.crmeth.2026.101480 · PMID 42259296 · PMCID PMC13494551 · OpenAlex W7163922001
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: optical imaging (calcium, voltage, 2-photon) (modality), mouse (organism), methods / tools (subfield)
Methods: Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Preprocessing, fMRI & imaging, Single-unit activity, calcium imaging, Connectivity
Keywords: orofacial behavior, facial dynamics, pose estimation, SLEAP, deep learning, brain-behavior coupling, neural activity prediction, widefield calcium imaging, mesoscale imaging, systems neuroscience
MeSH: Brain*, Deep Learning*, Face*, Animals, Behavior, Animal, Mice (* major topic)
Topic: Face Recognition and Perception (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: BLRD VA (I01 BX005978); NCI NIH HHS (P30 CA043703); American Brain Tumor Association; NIBIB NIH HHS (R00 EB027706); NINDS NIH HHS (R01 NS112499); National Institute of Biomedical Imaging and Bioengineering; Case Comprehensive Cancer Center
Citations: not cited yet (Europe PMC); 40 references in the paper
Research resources: Wildtype Animals Mouse Wildtype C57BL/6J RRID:IMSR_JAX:000664, B6.Cg-Tg(Camk2a-cre)T29-1Stl/J RRID:IMSR_JAX:005359, GCaMP6f Ai148(TIT2L-GC6f-ICL-tTA2)-D RRID:IMSR_JAX:030328, GCaMP6s Ai162(TIT2L-GC6s-ICL-tTA2)-D RRID:IMSR_JAX:031562, jGCaMP8mTIGRE2-jGCaMP8m-IRES-tTA2-WPRE RRID:IMSR_JAX:037718, MATLAB RRID:SCR_001622

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

Zenodo 19644866

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Deep Learning Toolbox (4 files), Signal Processing Toolbox (4 files), Statistics and Machine Learning Toolbox (4 files)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
5 files
At the source: zenodo.org/records/19644866

yyildirimlab/DeepFaceMouse

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 7ed40947a3ec1a06913a7dc3b33a5155cdf79d8f, 11 June 2026
Size: 2 files, 0 scripts
Software Heritage: not archived
Found in: “DeepFaceMouse pipeline architecture and availabi”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
2 files
At the source: github.com/yyildirimlab/DeepFaceMouse

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:

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

Code and data availability statement

The paper has a code and 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.1016/j.crmeth.2026.101480.

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 2, 28 September 2026

  • Authors: added Murat Yildirim (0000-0003-0853-2557); removed Murat Yildirim

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 17 authors, 10 keywords, 6 MeSH terms, 7 funders, 40 references, 6 RRIDs.

Cite

This paper

Ozdemirli, K., Connor, T., Kim, K., Unlu, E. A., Lacin, M. E., Maldonado, M., Bell, F., Leal, T. P., Oksuz, C., Sloan, A., Sarn, N., Chomyk, A., Trapp, B., Lathia, J. D., Mata, I., Eng, C., & Yildirim, M. (2026). DeepFaceMouse enables scalable prediction of large-scale brain activity from facial dynamics in mice. Cell reports methods, 6(8), 101480. https://doi.org/10.1016/j.crmeth.2026.101480

BibTeX

@article{ozdemirli2026deepfacemouse,
author = {Ozdemirli, Kemal and Connor, Tenesha and Kim, Kaleb and Unlu, Ersan Alp and Lacin, Macit Emre and Maldonado, Miguel and Bell, Frederick and Leal, Thiago Peixoto and Oksuz, Caglar and Sloan, Anthony and Sarn, Nicholas and Chomyk, Anthony and Trapp, Bruce and Lathia, Justin D and Mata, Ignacio and Eng, Charis and Yildirim, Murat},
title = {{DeepFaceMouse enables scalable prediction of large-scale brain activity from facial dynamics in mice}},
journal = {Cell reports methods},
year = {2026},
month = jun,
volume = {6},
number = {8},
pages = {101480},
publisher = {Elsevier},
issn = {2667-2375},
doi = {10.1016/j.crmeth.2026.101480},
url = {https://doi.org/10.1016/j.crmeth.2026.101480},
pmid = {42259296},
pmcid = {PMC13494551}
}

RIS

TY - JOUR
AU - Ozdemirli, Kemal
AU - Connor, Tenesha
AU - Kim, Kaleb
AU - Unlu, Ersan Alp
AU - Lacin, Macit Emre
AU - Maldonado, Miguel
AU - Bell, Frederick
AU - Leal, Thiago Peixoto
AU - Oksuz, Caglar
AU - Sloan, Anthony
AU - Sarn, Nicholas
AU - Chomyk, Anthony
AU - Trapp, Bruce
AU - Lathia, Justin D
AU - Mata, Ignacio
AU - Eng, Charis
AU - Yildirim, Murat
TI - DeepFaceMouse enables scalable prediction of large-scale brain activity from facial dynamics in mice
T2 - Cell reports methods
J2 - Cell Rep Methods
PY - 2026
DA - 2026/06/08
VL - 6
IS - 8
SP - 101480
SN - 2667-2375
PB - Elsevier
DO - 10.1016/j.crmeth.2026.101480
UR - https://doi.org/10.1016/j.crmeth.2026.101480
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.crmeth.2026.101480",
"type": "article-journal",
"title": "DeepFaceMouse enables scalable prediction of large-scale brain activity from facial dynamics in mice",
"container-title": "Cell reports methods",
"author": [
{
"family": "Ozdemirli",
"given": "Kemal"
},
{
"family": "Connor",
"given": "Tenesha"
},
{
"family": "Kim",
"given": "Kaleb"
},
{
"family": "Unlu",
"given": "Ersan Alp"
},
{
"family": "Lacin",
"given": "Macit Emre"
},
{
"family": "Maldonado",
"given": "Miguel"
},
{
"family": "Bell",
"given": "Frederick"
},
{
"family": "Leal",
"given": "Thiago Peixoto"
},
{
"family": "Oksuz",
"given": "Caglar"
},
{
"family": "Sloan",
"given": "Anthony"
},
{
"family": "Sarn",
"given": "Nicholas"
},
{
"family": "Chomyk",
"given": "Anthony"
},
{
"family": "Trapp",
"given": "Bruce"
},
{
"family": "Lathia",
"given": "Justin D"
},
{
"family": "Mata",
"given": "Ignacio"
},
{
"family": "Eng",
"given": "Charis"
},
{
"family": "Yildirim",
"given": "Murat"
}
],
"container-title-short": "Cell Rep Methods",
"volume": "6",
"issue": "8",
"page": "101480",
"DOI": "10.1016/j.crmeth.2026.101480",
"PMID": "42259296",
"PMCID": "PMC13494551",
"ISSN": "2667-2375",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.crmeth.2026.101480",
"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.1038/s41593-026-02262-8 [code]
Cheese3D enables sensitive detection and analysis of whole-face movement in mice.
Journal: Nature neuroscience
In common: mouse, 7 references
[2] 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: Signal Processing Toolbox, Statistics and Machine Learning Toolbox, mouse, 3 references
[3] doi:10.1038/s41467-026-75492-w [code]
Place and behavioral modulation of hippocampal neurons during immobility.
Journal: Nature communications
In common: Signal Processing Toolbox, Statistics and Machine Learning Toolbox, mouse, 3 references
[4] doi:10.1038/s41467-026-76581-6 [code]
Thalamocortical bursts encode reward contingencies and drive associative learning.
Journal: Nature communications
In common: Deep Learning Toolbox, Signal Processing Toolbox, Statistics and Machine Learning Toolbox, mouse, 1 reference
[5] doi:10.3389/fnins.2026.1790603 [code]
A novel behavioral paradigm using mice to study predictive postural control.
Journal: Frontiers in neuroscience
In common: mouse, 4 references
[6] doi:10.7554/elife.109240 [code]
Neural activity profiles reveal overlapping, intermingled subpopulations spanning area borders in mouse sensorimotor cortex.
Journal: eLife
In common: Statistics and Machine Learning Toolbox, optical imaging (calcium, voltage, 2-photon), mouse, 3 references
[7] doi:10.1038/s41467-026-73622-y [code]
Contextual gating of whisker-evoked responses by frontal cortex supports flexible decision making.
Journal: Nature communications
In common: Signal Processing Toolbox, Statistics and Machine Learning Toolbox, mouse, 3 references
[8] doi:10.1038/s41467-026-71664-w [code]
Dorsal prefrontal cortex drives perseverative behavior in mice.
Journal: Nature communications
In common: Signal Processing Toolbox, Statistics and Machine Learning Toolbox, mouse, 2 references
[9] doi:10.1038/s41598-026-52322-z [code]
A transparent wheel-based platform for locomotion-on-demand and multi-view body and facial kinematics in head-fixed mice.
Journal: Scientific reports
In common: Signal Processing Toolbox, Statistics and Machine Learning Toolbox, methods / tools, mouse, 2 references
[10] doi:10.3389/fendo.2026.1828487 [code]
Castration-induced nigrostriatal deficits are linked to reduced TrkB and loss of mature spines in the dorsal striatum.
Journal: Frontiers in endocrinology
In common: Signal Processing Toolbox, Statistics and Machine Learning Toolbox, mouse, 2 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.