OSCR

Model-based semantic distance reveals adaptive coordination of distinct cognitive systems in flexible knowledge retrieval.

Code ↔ Paper

12 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 12 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] § Methods › Functional system decomposition ↔ Demo/Script08_Factor_loading_heatmap.m, lines 38–58 · score 0.62 · negative Matrix Factorization, Orthogonal Projection, cross validation, OPNMF, dimensional, components
  2. [2] § Methods › Functional system decomposition ↔ OPNMF/opnmf.m, lines 1–42 · score 0.61 · negative Matrix Factorization, Orthogonal Projection, OPNMF, components, coefficient, error
  3. [3] § Methods › Multivariate predictive modelling ↔ Code/example/regression_tpls.m, lines 13–30 · score 0.61 · inner cross validation, Parameter optimization, bootstrap, PLS, fold, components
  4. [4] § Methods › Identification of model-based semantic distance signature ↔ Code/mvpa/dependency/Tor Wager/fast_haufe.m, the whole file · a weak match · score 0.59 · Haufe transformation, forward model, backward, weight
  5. [5] § Methods › Model-based quantification of semantic distance ↔ main/feature/get_vector.py, lines 190–234 · score 0.58 · fastText, word2vec, conceptNet, GloVe, vectors, dimensional
  6. [6] § Results › A robust neural signature predicts the continuum of semantic associations ↔ Code/mvpa/algorithm/thresholded partial least squares/examples/TPLS_example1.m, lines 64–109 · score 0.56 · brain predictive, fMRI, Thresholded Partial, map, PLS, Squares
  7. [7] § Results › A robust neural signature predicts the continuum of semantic associations ↔ Code/mvpa/algorithm/thresholded partial least squares/TPLSm/evalTuningParam.m, lines 6–55 · score 0.55 · tuning parameters, standard error, cross validation, MSE, component, Vector
  8. [8] § Results › Neural signature of semantic distance consists of three distinct cognitive systems ↔ OPNMF/opnmf.m, lines 1–42 · score 0.53 · negative Matrix Factorization, Orthogonal Projection, OPNMF, neural, distance
  9. [9] § Methods › Model-based quantification of semantic distance ↔ main/feature/get_vector.py, lines 29–59 · score 0.53 · fastText, word2vec, GloVe, words, Model
  10. [10] § Results › Model-based semantic distance reliably captures flexible retrieval demands ↔ main/feature/get_vector.py, lines 190–234 · score 0.52 · fastText, word2vec, conceptNet, GloVe, vectors, model
  11. [11] § Methods › Multivariate predictive modelling ↔ Code/example/regression_tpls.m, lines 54–75 · score 0.52 · fold inner, cross validation, squared, bootstrap, components, threshold
  12. [12] § Results › Neural signature of semantic distance consists of three distinct cognitive systems ↔ Demo/Script08_Factor_loading_heatmap.m, lines 38–58 · score 0.52 · negative Matrix Factorization, Orthogonal Projection, OPNMF, validated

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 · 496 lines · 19 KB · no license · 3 matches

  1. # -*- coding: utf-8 -*-
  2. """
  3. Module Help:
  4. get_word_vector_from_model
  5. Text_vector
  6. Clean_text
  7. Image_vector
  9. @author: Cheng Liu
  10. """
  11. import sys,os
  12. sys.path.append(os.getcwd())
  13. from feature.load_model import *
  15. import re
  16. import torchvision.transforms as transforms
  18. import nltk
  19. from nltk.corpus import stopwords
  21. # 尝试获取停用词，如果失败则下载后重试
  22. try:
  23. stop_words = stopwords.words('english')
  24. except LookupError: # NLTK 在未找到资源时会抛出 LookupError
  25. print("Stopwords resource not found. Downloading now...")
  26. nltk.download('stopwords')
  27. stop_words = stopwords.words('english') # 重新尝试加载停用词
  29. def get_word_vector_from_model(wordlist,model,dimension=300):
  30. """
  31. get vector of each word, if the word is not in this model, output nan
  33. Parameters
  34. ----------
  35. wordlist : list
  36. list of words
  37. model :
  38. glove, word2vec, fastText
  39. dimension : int
  41. Returns
  42. ----------
  43. wordvectorlist : list
  44. list of vecors of words
  46. """
  47. wordvectorlist = []
  48. for w in wordlist:
  49. try :
  50. vec = model[w]
  51. except :
  52. print('------------------------------')
  53. print(w + ' is not in this model!')
  54. print('------------------------------')
  55. vec = np.empty(dimension)
  56. vec[:] = np.nan
  58. wordvectorlist.append(vec)
  59. return wordvectorlist
  62. def Clean_text(sentencelist, ifstpw=0):
  63. """
  64. clean the text by delete punctuation and stopwords
  66. Parameters
  67. ----------
  68. sentencelist : list
  69. list of text
  70. ifstpw : bool
  71. if delete words in stopwords {0,1} default is 0, do not delete words
  73. Returns
  74. ----------
  75. wordlist : nested list
  76. list of word list
  78. """
  79. # delete punctuation, keep only letters
  80. wordlist = [re.sub(r'[^\w\s]', ' ', sentence).split() for sentence in sentencelist]
  81. if ifstpw == 1:
  82. # delete words in stopwords
  83. for i in range(len(wordlist)):
  84. wordlist[i] = [w for w in wordlist[i] if w.lower() not in stopwords]
  85. elif ifstpw == 0:
  86. for i in range(len(wordlist)):
  87. wordlist[i] = [w for w in wordlist[i]]
  88. return wordlist
  91. def get_vector_from_bert_model(modelpath,vectorType,chunks):
  92. """
  93. get vector from bert model by different vectorType
  95. Parameters
  96. ----------
  97. modelpath : str
  98. bert model path
  99. vectorType : str
  100. select your vector type of data
  101. 'word': get vector of each single word, data format is one word each row
  102. 'sentence': get vector of each sentence, data format is some words each row
  103. 'word_in_sentence': get vector of each word that in sentence (it means the word has a contextual information), data format is some words each row
  104. chunks : str in list
  105. divide all data into different chunk
  107. Returns
  108. ----------
  109. vectorlist :
  110. list of vector
  112. """
  113. model,tokenizer = get_bert_model(modelpath)
  114. print('< -- get bert model success! -- >')
  115. all_outputs = []
  117. if vectorType == 'sentence':
  118. #process by chunks
  119. outputs = []
  120. for chunk in chunks:
  121. input_ids = tokenizer.encode(chunk,add_special_tokens=True,return_tensors='pt')
  122. outputs = model(input_ids).last_hidden_state[0,1:-1,:].detach().numpy()
  123. all_outputs.append(outputs)
  125. elif vectorType == 'word' or vectorType == 'word_in_sentence':
  126. #process by chunks
  127. for chunk in chunks:
  128. if vectorType == 'word':
  129. chunk = [c.split() for c in chunk]
  130. input_ids = [tokenizer.encode(c,add_special_tokens=True,return_tensors='pt') for c in chunk]
  131. outputs = [model(inp).last_hidden_state[0,1:-1,:].detach().numpy() for inp in input_ids]
  132. all_outputs.append(outputs)
  134. return all_outputs
  136. def get_vector_from_gpt2_model(modelpath,vectorType,chunks):
  137. model,tokenizer = get_gpt2_model(modelpath)
  138. print('< -- get gpt2 model success! -- >')
  139. all_outputs = []
  141. if vectorType == 'sentence':
  142. #process by chunks
  143. for chunk in chunks:
  144. input_ids = tokenizer.encode(chunk,add_special_tokens=True,return_tensors='pt')
  145. outputs = model(input_ids).last_hidden_state[0,:,:].detach().numpy()
  146. all_outputs.append(outputs)
  148. elif vectorType == 'word' or vectorType == 'word_in_sentence':
  149. #process by chunks
  150. for chunk in chunks:
  151. chunk = [c.split() for c in chunk]
  152. input_ids = [tokenizer.encode(c,add_special_tokens=True,return_tensors='pt') for c in chunk]
  153. outputs = [model(inp).last_hidden_state[0,:,:].detach().numpy() for inp in input_ids]
  154. all_outputs.append(outputs)
  156. return all_outputs
  158. def get_vector_from_clip_model(modelpath,vectorType,chunks,multi='image'):
  159. if multi == 'text':
  160. model,_,tokenizer = get_clip_model(modelpath)
  161. print('< -- get clip model success! -- >')
  162. all_outputs = []
  164. if vectorType == 'sentence':
  165. #process by chunks
  166. for chunk in chunks:
  167. input_ids = tokenizer(chunk, padding=True, return_tensors="pt")
  168. outputs = model.get_text_features(**input_ids).detach().numpy()
  169. all_outputs.append(outputs)
  171. elif vectorType == 'word' or vectorType == 'word_in_sentence':
  172. for chunk in chunks:
  173. chunk = [c.split() for c in chunk]
  174. input_ids = [tokenizer(c, padding=True, return_tensors="pt") for c in chunk]
  175. outputs = [model.get_text_features(**inp).detach().numpy() for inp in input_ids]
  176. all_outputs.append(outputs)
  178. elif multi == 'image':
  179. model,processor,_ = get_clip_model(modelpath)
  180. print('< -- get clip model success! -- >')
  181. all_outputs = []
  183. for chunk in chunks:
  184. inputs_ids = processor(images=chunk, return_tensors="pt", padding=True)
  185. outputs = model.get_image_features(**inputs_ids).detach().numpy()
  186. all_outputs.append(outputs)
  188. return all_outputs
  190. def get_vector_from_pretrained_model(modeltype,modelpath,vectorType,chunks,dimension):
  191. if modeltype == 'glv':
  192. model = get_glove_model(modelpath)
  193. print('< -- get glove model success! -- >')
  194. elif modeltype == 'w2v':
  195. model = get_gensim_model(modelpath,binary = True)
  196. print('< -- get word2vec model success! -- >')
  197. elif modeltype == 'fast':
  198. model = get_gensim_model(modelpath,binary = False)
  199. print('< -- get fastText model success! -- >')
  200. elif modeltype == 'cnt':
  201. model = get_gensim_model(modelpath,binary = False)
  202. print('< -- get conceptNet model success! -- >')
  203. elif modeltype == 'rws':
  204. model = get_gensim_model(modelpath,binary = False)
  205. print('< -- get conceptNet model success! -- >')
  207. all_outputs = []
  209. if vectorType == 'word' or vectorType == 'word_in_sentence':
  210. for chunk in chunks:
  211. chunk = [c.split() for c in chunk]
  212. outputs = []
  213. for wl in chunk:
  214. wlvec = get_word_vector_from_model(wordlist = wl,model = model,dimension=dimension)
  215. outputs.append(np.array(wlvec))
  216. all_outputs.append(outputs)
  218. elif vectorType == 'sentence':
  219. for chunk in chunks:
  220. chunk = [c.split() for c in chunk]
  221. outputs = []
  222. for wl in chunk:
  223. wlvec = get_word_vector_from_model(wordlist = wl,model = model,dimension=dimension)
  224. wlvec = [v for v in wlvec if np.isnan(v).any() == 0]
  225. if len(wlvec) == 0:
  226. vec = np.empty(dimension)
  227. vec[:] = np.nan
  228. outputs.append(vec)
  229. else :
  230. outputs.append(np.mean(wlvec,axis=0))
  232. all_outputs.append(outputs)
  234. return all_outputs
  236. def get_vector_from_elmo_model(modelpath,vectorType,chunks):
  237. model = get_elmo_model(modelpath)
  238. print('< -- get elmo model success! -- >')
  240. all_outputs = []
  242. if vectorType == 'word':
  243. # process by chunks
  244. for chunk in chunks:
  245. chunk = [c.split() for c in chunk]
  246. chunk = [[c] for c in chunk]
  247. character_ids = [batch_to_ids(c) for c in chunk]
  248. outputs = [model(cha)['elmo_representations'][0].detach().numpy().squeeze() for cha in character_ids]
  250. all_outputs.append(outputs)
  252. elif vectorType == 'sentence' :
  253. for chunk in chunks:
  254. chunk = [[c] for c in chunk]
  255. character_ids = batch_to_ids(chunk)
  256. out = model(character_ids)['elmo_representations'][0].detach().numpy()
  257. outputs = []
  258. for o in out:
  259. non_zero_rows = [i for i in range(o.shape[0]) if np.any(o[i])]
  260. outputs.append(o[non_zero_rows].squeeze())
  262. outputs = np.array(outputs)
  263. all_outputs.append(outputs)
  265. elif vectorType == 'word_in_sentence':
  266. for chunk in chunks:
  267. chunk = [c.split() for c in chunk]
  268. character_ids = batch_to_ids(chunk)
  269. out = model(character_ids)['elmo_representations'][0].detach().numpy()
  270. outputs = []
  271. for o in out:
  272. non_zero_rows = [i for i in range(o.shape[0]) if np.any(o[i])]
  273. outputs.append(o[non_zero_rows].squeeze())
  275. all_outputs.append(outputs)
  277. return all_outputs
  279. def get_vector_from_vgg_model(modelpath,vectorType,chunks):
  280. model = get_vgg_model(modelpath)
  282. print('< -- get elmo model success! -- >')
  284. preprocess = transforms.Compose([
  285. transforms.Resize((224, 224)), # 调整图像大小为 224x224
  286. transforms.ToTensor(),
  287. transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
  288. ])
  290. all_outputs = []
  292. for chunk in chunks:
  293. chunk = [preprocess(c).unsqueeze(0) for c in chunk]
  294. outputs = np.array([model(c).data.numpy().squeeze() for c in chunk])
  295. all_outputs.append(outputs)
  297. return all_outputs
  299. def out_vec_by_word(sentencelist,label,all_outputs,matchfile,outpath,filetype,outword):
  300. ## merge all chunks
  301. sentencevectorlist = []
  302. outputslist = []
  303. for out in all_outputs:
  304. outlist = []
  305. for o in out:
  306. outlist.append(o)
  307. outputslist.extend(outlist)
  309. print('< -- output vectorlist success! -- >')
  310. ## output results
  311. if matchfile == None:
  312. for i in range(len(outputslist)):
  313. sentencevectorlist = outputslist[i]
  314. outpath = '../results/Vector_' + label + '_word_in_sentence_' + str(i)+ '.' + filetype
  315. savefiles(sentencelist[i].split(),sentencevectorlist,outpath,filetype,outword)
  317. else:
  318. matchf = readfiles(matchfile)
  319. for m in range(len(matchf)):
  320. idx = sentencelist[m].split().index(matchf[m])
  321. sentencevectorlist.append(outputslist[m][idx])
  322. savefiles(matchf,sentencevectorlist,outpath,filetype,outword)
  324. return sentencevectorlist
  326. def out_vec_by_row(sentencelist,all_outputs,outpath,filetype,outword):
  327. ## merge outputs
  328. outputslist = []
  329. sentencevectorlist = []
  330. for out in all_outputs:
  331. outputslist.extend(out)
  332. sentencevectorlist = [arr.flatten() for arr in outputslist]
  333. ## output results
  334. savefiles(sentencelist,sentencevectorlist,outpath,filetype,outword)
  336. return sentencevectorlist
  338. def Text_vector(file, vectorType, label = 'gpt2_base',filetype = 'csv', outword = 'n', ifstpw=0, matchfile = None):
  339. """
  340. get vector of each row of text, if the word is not in this model, output nan
  342. Parameters
  343. ----------
  344. file : file
  345. Text filepath
  346. label : str
  347. model label (unique singal for getting the model that you want to load)
  348. filetype : str, optional
  349. you can select outfile format {'txt','csv','xlsx'}, default format is csv
  350. outword : str, optional
  351. you can select if output words and vectors into one file {'n','y'}
  352. ifstpw : bool
  353. whether delete words in stopwords {0,1} default is 0, do not delete words
  354. vectorType : str, optional
  355. you can select which type of vector you want {'word','sentence'}
  356. --> 'sentence': default, output one vector of each row of data
  357. --> 'word': output vectors for each word of each row of data
  358. matchfile : str, optional
  360. Returns
  361. ----------
  362. output a file include Text(optional) and vectors
  364. """
  365. ## load data as list
  366. if isinstance(file, list):
  367. sentencelist = file
  368. else:
  369. sentencelist = readfiles(file)
  370. print('< -- read files as sentencelist success! -- >')
  372. ## divide text
  373. chunk_size = 500
  374. chunks = [sentencelist[i:i + chunk_size] for i in range(0, len(sentencelist), chunk_size)]
  376. ## get current model info
  377. modelinfo = get_modelInfo()
  378. if label in modelinfo['label'].values:
  379. modeltype = modelinfo.loc[modelinfo['label'] == label,'modeltype'].values[0]
  380. modelpath = modelinfo.loc[modelinfo['label'] == label,'modelpath'].values[0]
  381. dimension = int(modelinfo.loc[modelinfo['label'] == label,'dimension'].values[0])
  382. else:
  383. print("There is no such label in the models list, please add model info in models/modelinfo.csv")
  385. ## get outpath
  386. print('< -- get modelinformation success! -- >')
  387. ## output information
  388. if not os.path.exists('../results'):
  389. os.makedirs('../results')
  390. outpath = '../results/Vector_' + label + '.' + filetype
  392. ## load data file to list
  393. if vectorType == 'sentence':
  395. if modeltype == 'bert':
  396. all_outputs = get_vector_from_bert_model(modelpath,vectorType,chunks)
  398. elif modeltype == 'gpt2':
  399. all_outputs = get_vector_from_gpt2_model(modelpath,vectorType,chunks)
  401. elif modeltype == 'clip':
  402. all_outputs = get_vector_from_clip_model(modelpath,vectorType,chunks,multi='text')
  404. elif modeltype == 'glv' or modeltype == 'w2v' or modeltype == 'fast' or modeltype == 'cnt' or modeltype == 'rws':
  405. all_outputs = get_vector_from_pretrained_model(modeltype,modelpath,vectorType,chunks,dimension)
  407. elif modeltype == 'elmo':
  408. all_outputs = get_vector_from_elmo_model(modelpath,vectorType,chunks)
  410. else :
  411. print('please check if the modeltype is right:{"bert","glv","w2v","gpt2","clip","fast","rws","elmo","cnt"}')
  413. sentencevectorlist = out_vec_by_row(sentencelist,all_outputs,outpath,filetype,outword)
  415. elif vectorType == 'word' or vectorType == 'word_in_sentence':
  417. ## select different model
  418. if modeltype == 'bert':
  419. all_outputs = get_vector_from_bert_model(modelpath,vectorType,chunks)
  421. elif modeltype == 'gpt2':
  422. all_outputs = get_vector_from_gpt2_model(modelpath,vectorType,chunks)
  424. elif modeltype == 'clip':
  425. all_outputs = get_vector_from_clip_model(modelpath,vectorType,chunks,multi='text')
  427. elif modeltype == 'glv' or modeltype == 'w2v' or modeltype == 'fast' or modeltype == 'cnt' or modeltype == 'rws':
  428. all_outputs = get_vector_from_pretrained_model(modeltype,modelpath,vectorType,chunks,dimension)
  430. elif modeltype == 'elmo':
  431. all_outputs = get_vector_from_elmo_model(modelpath,vectorType,chunks)
  433. else :
  434. print('please check if the modeltype is right:{"bert","glv","w2v","gpt2","clip","fast","rws","elmo","cnt"}')
  436. print('< -- get vector success! -- >')
  437. if vectorType == 'word_in_sentence':
  438. sentencevectorlist = out_vec_by_word(sentencelist,label,all_outputs,matchfile,outpath,filetype,outword)
  439. elif vectorType == 'word':
  440. sentencevectorlist = out_vec_by_row(sentencelist,all_outputs,outpath,filetype,outword)
  442. print('< -- results has output -- >')
  443. print(outpath)
  444. return sentencevectorlist
  447. def Image_vector(imagefile, label = 'clip_base', filetype = 'csv', outword = 'n', vectorType = None):
  448. """
  449. get vector of each row of image
  451. Parameters
  452. ----------
  453. imagefile : file
  454. image path
  455. filetype : str, optional
  456. you can select outfile format {'txt','csv','xlsx'}, default format is csv
  457. outword : str, optional
  458. you can select if output words and vectors into one file {'n','y'}
  460. Returns
  461. ----------
  462. output a file include Text(optional) and vectors
  463. """
  465. modelinfo = get_modelInfo()
  466. if label in modelinfo['label'].values:
  467. modeltype = modelinfo.loc[modelinfo['label'] == label,'modeltype'].values[0]
  468. modelpath = modelinfo.loc[modelinfo['label'] == label,'modelpath'].values[0]
  469. dimension = int(modelinfo.loc[modelinfo['label'] == label,'dimension'].values[0])
  470. else:
  471. print("There is no such label in the models list, please add model info in models/modelinfo.csv")
  473. ## output information
  474. if not os.path.exists('results'):
  475. os.makedirs('results')
  476. outpath = 'results/Vector_' + label + '.' + filetype
  478. imagelist = readfiles(imagefile)
  479. image = [Image.open(f).convert("RGB") for f in imagelist]
  481. ## divide text
  482. chunk_size = 500
  483. chunks = [image[i:i + chunk_size] for i in range(0, len(image), chunk_size)]
  485. if modeltype == 'clip':
  486. all_outputs = get_vector_from_clip_model(modelpath,vectorType,chunks,multi='image')
  487. elif modeltype == 'vgg':
  488. all_outputs = get_vector_from_vgg_model(modelpath,vectorType,chunks)
  489. else :
  490. print('please check if the modeltype is right:{"bert","glv","w2v","gpt2","clip","fast","rws","elmo","cnt"}')
  492. ## merge outputs
  493. sentencevectorlist = out_vec_by_row(imagelist,all_outputs,outpath,filetype,outword)
  494. print('< -- results has output -- >')
  496. return sentencevectorlist

get_vector.py at commit 87e3334, no license · at the source

Overview

Authors: Kaixiang Zhuang1, Xinyu Liang1, Jonathan Smallwood2, Elizabeth Jefferies3, Deniz Vatansever1
ORCID iDs: Kaixiang Zhuang, Xinyu Liang, Jonathan Smallwood, Elizabeth Jefferies, Deniz Vatansever
  1. Institute of Science and Technology for Brain-inspired Intelligence, Fudan University,Shanghai, China
  2. Department of Psychology, Queen’s University,Ontario, Canada
  3. Department of Psychology, University of York,York, United Kingdom
Institutions: Fudan University (China); Queen's University (Canada); University of York (United Kingdom)
Journal: Nature communications, volume 17, issue 1, article 8936
Dates: received 28 November 2025; accepted 14 July 2026; published online 22 July 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-75841-9 · PMID 42637769 · PMCID PMC13503705 · OpenAlex W7170052645
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), cognitive (subfield)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, fMRI & imaging
Keywords: Long-term memory, Language
MeSH: Brain*, Cognition*, Knowledge*, Semantics*, Brain Mapping, Humans, Language, Machine Learning, Magnetic Resonance Imaging, Models, Neurological (* major topic)
Topic: Neurobiology of Language and Bilingualism (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Funding: Ministry of Science and Technology of the People's Republic of China (2022ZD0207900); National Natural Science Foundation of China (National Science Foundation of China) (32400858); China Postdoctoral Science Foundation (2022M720820)
Citations: cited by 1 paper (Europe PMC); 89 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 12 matches between paragraphs and lines of code.

lc451574367/Embedding

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 87e3334679c886f18f1289687185568b22cdad21, 18 May 2024
Languages: Python (11)
Size: 27 files, 11 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, tests
Not found: license file, CITATION.cff, environment file, continuous integration, documentation
Tools: PyTorch (4 files), Pillow (3 files), Hugging Face Transformers (3 files), NumPy (2 files), pandas (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
12 files
At the source: github.com/lc451574367/Embedding

cognizelab/fmatrix-OPNMF

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 885fbd5772565766a653611bf41d3a9b25edeca7, 30 March 2026
Languages: MATLAB (25)
Size: 35 files, 25 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, CITATION.cff
Not found: license file, environment file, tests, continuous integration, documentation
Tools: Statistics and Machine Learning Toolbox (4 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
26 files
At the source: github.com/cognizelab/fmatrix-OPNMF

cognizelab/semantic-distance-signature

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 4e9f962c5cfce6ed7dcb7099be2b6d6a8751bb26, 7 July 2026
Languages: MATLAB (191)
Size: 230 files, 191 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, documentation
Not found: CITATION.cff, environment file, tests, continuous integration
Tools: Statistics and Machine Learning Toolbox (33 files), Parallel Computing Toolbox (2 files), SPM (1 file), Violinplot-Matlab (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
193 files
At the source: github.com/cognizelab/semantic-distance-signature

Zenodo 21161485

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: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Statistics and Machine Learning Toolbox (33 files), Parallel Computing Toolbox (2 files), SPM (1 file), Violinplot-Matlab (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
192 files
At the source:

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/s41467-026-75841-9.

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:

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

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:

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s41467-026-75841-9.

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, 5 authors, 2 keywords, 10 MeSH terms, 3 funders, 81 references.

Cite

This paper

Zhuang, K., Liang, X., Smallwood, J., Jefferies, E., & Vatansever, D. (2026). Model-based semantic distance reveals adaptive coordination of distinct cognitive systems in flexible knowledge retrieval. Nature communications, 17(1), 8936. https://doi.org/10.1038/s41467-026-75841-9

BibTeX

@article{zhuang2026model,
author = {Zhuang, Kaixiang and Liang, Xinyu and Smallwood, Jonathan and Jefferies, Elizabeth and Vatansever, Deniz},
title = {{Model-based semantic distance reveals adaptive coordination of distinct cognitive systems in flexible knowledge retrieval}},
journal = {Nature communications},
year = {2026},
month = jul,
volume = {17},
number = {1},
pages = {8936},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-75841-9},
url = {https://doi.org/10.1038/s41467-026-75841-9},
pmid = {42637769},
pmcid = {PMC13503705}
}

RIS

TY - JOUR
AU - Zhuang, Kaixiang
AU - Liang, Xinyu
AU - Smallwood, Jonathan
AU - Jefferies, Elizabeth
AU - Vatansever, Deniz
TI - Model-based semantic distance reveals adaptive coordination of distinct cognitive systems in flexible knowledge retrieval
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/07/22
VL - 17
IS - 1
SP - 8936
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-75841-9
UR - https://doi.org/10.1038/s41467-026-75841-9
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-75841-9",
"type": "article-journal",
"title": "Model-based semantic distance reveals adaptive coordination of distinct cognitive systems in flexible knowledge retrieval",
"container-title": "Nature communications",
"author": [
{
"family": "Zhuang",
"given": "Kaixiang"
},
{
"family": "Liang",
"given": "Xinyu"
},
{
"family": "Smallwood",
"given": "Jonathan"
},
{
"family": "Jefferies",
"given": "Elizabeth"
},
{
"family": "Vatansever",
"given": "Deniz"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "8936",
"DOI": "10.1038/s41467-026-75841-9",
"PMID": "42637769",
"PMCID": "PMC13503705",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-75841-9",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
22
]
]
}
}

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/s41467-026-73153-6 [code]
Latent neural architecture organising shared aesthetic evaluations of visual artworks.
Journal: Nature communications
In common: Pillow, PyTorch, Statistics and Machine Learning Toolbox, 2 other tools, cognitive, 8 references, 3 authors
[2] doi:10.1002/hbm.70536 [code]
The Neural Processes Underpinning Flexible Semantic Retrieval in Visual and Auditory Modalities.
Journal: Human brain mapping
In common: NumPy, cognitive, 15 references
[3] doi:10.1073/pnas.2528851123 [code]
Sender-receiver subdivisions of the default mode network in perceptual and memory-guided cognition.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: NumPy, cognitive, 7 references, 2 authors
[4] doi:10.1162/imag.a.1281
Syntactic processing engages the semantic control network.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: 13 references
[5] doi:10.1162/nol.a.244 [code]
A Novel Approach to Map the Causal Impact of Brain Stimulation on Semantic Processing With Language Models.
Journal: Neurobiology of language (Cambridge, Mass.)
In common: Hugging Face Transformers, PyTorch, NumPy, 11 references
[6] doi:10.1038/s41467-026-71568-9 [code]
Convergent and selective representations of pain, appetitive processes, aversive processes, and cognitive control in the insula.
Journal: Nature communications
In common: Parallel Computing Toolbox, SPM, Pillow, 3 other tools, cognitive, 5 references
[7] doi:10.1038/s41593-026-02205-3 [code]
Competitive interactions shape mammalian brain network dynamics and computation.
Journal: Nature neuroscience
In common: Parallel Computing Toolbox, SPM, PyTorch, 3 other tools, 5 references
[8] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: Hugging Face Transformers, SPM, Pillow, 3 other tools, cognitive, 4 references
[9] doi:10.1038/s41467-026-74565-0 [code]
The functional neurobiology of dispositions towards negative emotions.
Journal: Nature communications
In common: Violinplot-Matlab, Parallel Computing Toolbox, SPM, 3 other tools, cognitive, 3 references
[10] doi:10.1162/imag.a.1201 [code]
All spectral frequencies of neural activity reveal semantic representation in the human anterior ventral temporal cortex.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Parallel Computing Toolbox, SPM, Statistics and Machine Learning Toolbox, 1 other tool, 5 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.