OSCR

Modeling the hallucinatory effects of classical psychedelics in terms of replay-dependent plasticity mechanisms.

Code ↔ Paper

8 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 8 matches
  1. [1] § Methods › Model architecture and training ↔ beyond_backprop/algorithms/common/layer.py, lines 281–315 · score 0.64 · dendritic branch, batch normalization, affine, nonlinearities, multicompartmental, bias
  2. [2] § Methods › Generating hallucinations in hierarchical variational autoencoders ↔ halluc.ipynb, lines 19–68 · score 0.63 · Tiny ImageNet, VDVAE models, trained models, VAEs
  3. [3] § Methods › Classifier training ↔ beyond_backprop/algorithms/image_classification.py, lines 19–147 · score 0.59 · cross entropy loss, classifier, phase, algorithm, trained, network
  4. [4] § Results › Mapping the Wake-Sleep algorithm onto cortical architecture ↔ beyond_backprop/algorithms/wake_sleep/rm_wake_sleep.py, lines 37–54 · score 0.59 · Wake Sleep algorithm, Wake phase, Sleep phase, inference, architecture, layer
  5. [5] § Methods › Classifier training ↔ beyond_backprop/algorithms/algorithm.py, lines 28–95 · score 0.56 · cross entropy loss, phase, class, algorithm, trained, network
  6. [6] § Methods › Model architecture and training ↔ beyond_backprop/algorithms/wake_sleep/callbacks.py, lines 511–582 · score 0.55 · inference mode, network activity, Wake Sleep, plasticity, CIFAR10, MNIST
  7. [7] § Methods › Quantifying interareal causality through inactivations ↔ beyond_backprop/algorithms/wake_sleep/callbacks.py, lines 511–582 · score 0.53 · prevent numerical instability, ratio, variances
  8. [8] § Results › Effects of psychedelics on single neurons ↔ beyond_backprop/algorithms/wake_sleep/callbacks.py, lines 126–192 · score 0.51 · apical plasticity, dose dependent, Wake Sleep, gated, psychedelic, basal

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 · 694 lines · 34 KB · MIT · 3 matches

  1. """
  2. Analysis code for processing trained networks
  4. These are callbacks, called by Pytorch Lightning functionality at various points in training
  6. Results are stored in the logs folder
  7. """
  9. from __future__ import annotations
  11. from logging import getLogger as get_logger
  12. from pathlib import Path
  13. import torch
  14. from lightning import Callback, Trainer
  15. from torch import Tensor
  16. import cv2
  17. from collections import defaultdict
  19. from beyond_backprop.algorithms.algorithm import Algorithm
  20. from beyond_backprop.datamodules.dataset_normalizations import cifar10_unnormalization
  21. import matplotlib.pyplot as plt
  22. import numpy as np
  23. from sklearn.decomposition import PCA
  24. from torch.distributions.multivariate_normal import MultivariateNormal
  25. logger = get_logger(__name__)
  26. basal_color = '#72a6ca'
  27. apical_color = '#e0474c'
  28. fontsize = 5
  30. def generated_image_plot(sample_data, log_dir):
  31. """
  32. Plotting function for the GenerativeSamples Callback
  33. """
  34. fig, axes = plt.subplots(2, 5, sharey = True, figsize = (7.5, 3))
  35. fig.suptitle('sample generated image', fontsize = fontsize)
  36. idx = 0
  37. shape = sample_data[idx,...].shape
  38. if shape[0] == 3 and shape[1] == 32:
  39. cifar10 = True
  40. else:
  41. cifar10 = False
  42. for ii in range(0,2):
  43. for jj in range(0,5):
  44. if cifar10:
  45. axes[ii,jj].imshow(cifar10_unnormalization(torch.tensor(sample_data[idx,...].permute(1,2,0))))
  46. else:
  47. axes[ii,jj].imshow(torch.tensor(sample_data[idx,...].permute(1,2,0)), cmap = 'gray', vmin = -1, vmax = 1)
  48. axes[ii,jj].tick_params(left=False,
  49. bottom=False,
  50. labelleft=False,
  51. labelbottom=False)
  52. idx = idx + 1
  53. plt.savefig(str(log_dir / "gen_images.pdf"), format = 'pdf')
  54. return
  56. class GenerativeSamples(Callback):
  57. def __init__(self) -> None:
  58. """
  59. Callback that plots generative samples from a trained InfGenNetwork after testing
  60. """
  61. super().__init__()
  63. def on_test_end(self, trainer: Trainer, pl_module: Algorithm) -> None:
  64. pl_module.network.gen_forward()
  65. sample_data = pl_module.network.gen_ts[-1].gen_output.cpu()
  66. if trainer is not None:
  67. # Use the Trainer's log dir if we have a trainer. (NOTE: we should always have one,
  68. # except maybe during some unit tests where the DataModule is used by itself.)
  69. log_dir = Path(trainer.log_dir or log_dir)
  71. generated_image_plot(sample_data, log_dir)
  72. return
  74. class SimRecord(defaultdict):
  75. __getattr__= defaultdict.__getitem__
  76. __setattr__= defaultdict.__setitem__
  77. __delattr__= defaultdict.__delitem__
  79. def default_factory():
  80. return []
  82. def inf_gen_loss_plot(record, log_dir):
  83. """
  84. Plotting the network inference and generative losses
  85. """
  86. fig, axes = plt.subplots(1, 2, sharey = False, figsize = (3,1.5), layout='constrained')
  87. fig.suptitle('Loss curves', fontsize = fontsize)
  88. axes[0].plot(torch.tensor(record.inf_loss), color = basal_color)
  89. axes[0].set_yscale('symlog')
  90. axes[0].set_title('inf_loss', color = basal_color, fontsize = fontsize)
  91. axes[1].plot(torch.tensor(record.gen_loss), color = apical_color)
  92. axes[1].set_yscale('symlog')
  93. axes[1].set_title('gen_loss', color = apical_color, fontsize = fontsize)
  94. axes[0].spines.top.set_visible(False)
  95. axes[0].spines.right.set_visible(False)
  96. axes[1].spines.top.set_visible(False)
  97. axes[1].spines.right.set_visible(False)
  99. plt.savefig(str(log_dir / "loss.pdf"), format = 'pdf')
  100. return
  102. class InfGenLossRecord(Callback):
  103. def __init__(self) -> None:
  104. """
  105. Callback that records inference and generative losses for a network during training and generates plots
  106. """
  107. super().__init__()
  108. self.record = SimRecord(default_factory)
  110. def on_train_batch_end(
  111. self, trainer: Trainer, pl_module: Algorithm, outputs, batch: tuple[Tensor, Tensor], batch_idx: int
  112. ) -> None:
  113. self.record.inf_loss.append(pl_module.pre_grad_inf.detach())
  114. self.record.gen_loss.append(pl_module.pre_grad_gen.detach())
  115. return
  117. def on_test_end(self, trainer: Trainer, pl_module: Algorithm) -> None:
  118. if trainer is not None:
  119. # Use the Trainer's log dir if we have a trainer. (NOTE: we should always have one,
  120. # except maybe during some unit tests where the DataModule is used by itself.)
  121. log_dir = Path(trainer.log_dir or log_dir)
  123. inf_gen_loss_plot(self.record, log_dir)
  124. return
  126. def plasticity_quant_plot(total_apical_plasticity, total_apical_plasticity_sem, total_basal_plasticity, total_basal_plasticity_sem, apical_cossim, basal_cossim, log_dir):
  127. """Plotting function for analyzing psychedelic-induced increases in plasticity"""
  128. if len(total_apical_plasticity) == 11:
  129. mixing_constant = torch.arange(0,1.1,0.1)
  130. else:
  131. mixing_constant = torch.arange(0,1,0.2)
  132. fig, axes = plt.subplots(1,1, figsize = (3,3))
  133. axes.errorbar(mixing_constant, total_apical_plasticity, yerr = total_apical_plasticity_sem, color = apical_color, ecolor = apical_color)
  134. axes.errorbar(mixing_constant, (1-mixing_constant) * total_apical_plasticity, yerr = (1-mixing_constant) * total_apical_plasticity_sem, color = 'k', ecolor = 'k')
  135. axes.set_title('apical')
  136. plt.legend(['without gating', 'with gating'])
  137. axes.set_ylim([0, torch.max(total_apical_plasticity)])
  138. axes.set_xlabel(r'$\alpha$', fontsize = fontsize)
  139. axes.set_ylabel('total plasticity', fontsize = fontsize)
  141. axes.spines.top.set_visible(False)
  142. axes.spines.right.set_visible(False)
  143. axes.tick_params(axis = 'both', which = 'major', labelsize=fontsize)
  144. axes.tick_params(axis = 'both', which = 'minor', labelsize = fontsize)
  146. plt.tight_layout()
  147. fig.suptitle('Dose dependence of apical plasticity', fontsize = fontsize)
  148. fig.savefig(str(log_dir / "Plasticity Quant Apical.pdf"), format = 'pdf')
  150. fig_2, axes_2 = plt.subplots(1,1, figsize = (3,3))
  152. axes_2.errorbar(mixing_constant, total_basal_plasticity, yerr = total_basal_plasticity_sem, color = basal_color, ecolor = basal_color)
  153. axes_2.errorbar(mixing_constant, mixing_constant * total_basal_plasticity, yerr = (mixing_constant) * total_basal_plasticity_sem, color = 'k', ecolor = 'k')
  154. axes_2.set_title('basal')
  156. plt.legend(['without gating', 'with gating'])
  157. axes_2.set_ylim([0, torch.max(total_basal_plasticity)])
  158. axes_2.set_xlabel(r'$\alpha$', fontsize = fontsize)
  159. axes_2.set_ylabel('total plasticity', fontsize = fontsize)
  161. axes_2.spines.top.set_visible(False)
  162. axes_2.spines.right.set_visible(False)
  163. axes_2.tick_params(axis = 'both', which = 'major', labelsize=fontsize)
  164. axes_2.tick_params(axis = 'both', which = 'minor', labelsize = fontsize)
  166. plt.tight_layout()
  167. fig_2.suptitle('Dose dependence of basal plasticity', fontsize = fontsize)
  168. fig_2.savefig(str(log_dir / "Plasticity Quant Basal.pdf"), format = 'pdf')
  170. fig_3, axes_3 = plt.subplots(1,2, figsize = (3,1.5))
  171. axes_3[0].scatter(mixing_constant, apical_cossim, color = apical_color)
  172. axes_3[1].scatter(mixing_constant, basal_cossim, color = basal_color)
  173. axes_3[0].set_title('apical')
  174. axes_3[1].set_title('basal')
  175. axes_3[0].set_xlabel(r'$\alpha$', fontsize = fontsize)
  176. axes_3[0].set_ylabel('cosine sim', fontsize = fontsize)
  177. axes_3[1].set_xlabel(r'$\alpha$', fontsize = fontsize)
  178. axes_3[1].set_ylabel('cosine sim', fontsize = fontsize)
  179. axes_3[0].set_ylim([0,1])
  180. axes_3[1].set_ylim([0,1])
  181. axes_3[0].spines.top.set_visible(False)
  182. axes_3[0].spines.right.set_visible(False)
  183. axes_3[1].spines.top.set_visible(False)
  184. axes_3[1].spines.right.set_visible(False)
  185. axes_3[0].tick_params(axis = 'both', which = 'major', labelsize=fontsize)
  186. axes_3[0].tick_params(axis = 'both', which = 'minor', labelsize = fontsize)
  187. axes_3[1].tick_params(axis = 'both', which = 'major', labelsize=fontsize)
  188. axes_3[1].tick_params(axis = 'both', which = 'minor', labelsize = fontsize)
  189. plt.tight_layout()
  190. fig_3.suptitle('Dose dependence of plasticity cosine sim', fontsize = fontsize)
  191. fig_3.savefig(str(log_dir / "Plasticity Quant Cosine Sim.pdf"), format = 'pdf')
  192. return
  194. def apical_basal_alignment_plot(record, log_dir):
  195. """Plotting function for analyzing alignment between the apical and basal dendrites"""
  196. plt.figure()
  197. fig, axes = plt.subplots(1, 5, figsize = (7.5,1.5))
  198. basal = torch.vstack(record.basal).cpu()
  199. apical = torch.vstack(record.apical).cpu()
  200. fig.suptitle('Apical Basal Alignment', fontsize = fontsize)
  201. for idx in range(0,4):
  202. axes[idx].scatter(basal[:, idx], apical[:, idx])
  203. axes[idx].plot([-1, 1], [-1,1])
  205. basal_standardized = (basal - torch.mean(basal, axis = 0, keepdim = True))/torch.std(basal, axis = 0, keepdim = True)
  206. apical_standardized = (apical - torch.mean(apical, axis = 0, keepdim = True))/torch.std(apical, axis = 0, keepdim = True)
  207. corr = basal_standardized.T @ apical_standardized/ basal_standardized.shape[0]
  208. diag = torch.diag(corr)
  209. N = len(diag)
  210. off_diag = corr.flatten()[1:].view(N-1, N+1)[:,:-1].flatten()
  212. K = 1
  213. axes[4].imshow(corr[0:K, 0:K], vmin = -1, vmax = 1)
  214. axes[4].set_title('apical and basal correlations', fontsize = fontsize)
  215. axes[4].set_ylabel('basal neuron #', fontsize = fontsize)
  216. axes[4].set_xlabel('apical neuron #', fontsize = fontsize)
  218. fig, axes = plt.subplots(1,1, figsize = (1.5,1.5))
  219. axes.boxplot([off_diag, diag], tick_labels = ['rand.', 'same'], showfliers = False)
  221. axes.set_yticks([-0.5, 0, 0.5, 1])
  222. axes.set_ylim([-0.5, 1.2])
  223. axes.set_yticklabels([-0.5, 0, 0.5, 1], fontsize = fontsize)
  224. axes.spines.top.set_visible(False)
  225. axes.spines.right.set_visible(False)
  226. axes.set_ylabel('correlation', fontsize = fontsize)
  227. plt.tight_layout()
  228. plt.savefig(str(log_dir / "Apical Basal Alignment.pdf"), format = 'pdf')
  229. return
  231. class ApicalBasalAlignment(Callback):
  232. "Callback for quantifying the degree of apical-basal alignment for a given network"
  233. def __init__(self) -> None:
  234. """
  235. Callback that records network activation variables for a network during training
  236. """
  237. super().__init__()
  238. self.record = SimRecord(default_factory)
  240. def on_test_batch_end(
  241. self, trainer: Trainer, pl_module: Algorithm, outputs, batch: tuple[Tensor, Tensor], batch_idx: int, dataloader_idx = 0
  242. ) -> None:
  243. pl_module.network.forward(pl_module.x)
  244. self.record.basal.append(pl_module.network.ts[2].output)
  245. pl_module.network.gen_log_prob()
  246. self.record.apical.append(pl_module.network.ts[2].predicted_activity_gen[0])
  247. return
  249. def on_test_end(self, trainer: Trainer, pl_module: Algorithm) -> None:
  250. if trainer is not None:
  251. # Use the Trainer's log dir if we have a trainer. (NOTE: we should always have one,
  252. # except maybe during some unit tests where the DataModule is used by itself.)
  253. log_dir = Path(trainer.log_dir or log_dir)
  255. apical_basal_alignment_plot(self.record, log_dir)
  256. return
  258. def fig2rgb_array(fig):
  259. fig.canvas.draw()
  260. buf = fig.canvas.tostring_rgb()
  261. ncols, nrows = fig.canvas.get_width_height()
  262. return np.fromstring(buf, dtype=np.uint8).reshape(nrows, ncols, 3)
  264. def figure_to_array(fig):
  265. fig.canvas.draw()
  266. fig_array = fig2rgb_array(fig)
  267. fig_array = fig_array[:,:,[2,1,0]]
  268. return fig_array
  270. def dynamic_mixed_samples_pyplot(sample_data, log_dir):
  271. """Function for storing a hallucination sequence as a video"""
  272. sample_data[torch.where(sample_data < 0)] = 0
  273. sample_data[torch.where(sample_data > 1)] = 1
  274. file_handle = 'Dynamic mixed samples image.mp4'
  275. filename = str(log_dir / file_handle)
  276. frame_size = (1000, 1000)
  277. output = cv2.VideoWriter(filename, cv2.VideoWriter_fourcc(*'mp4v'), 60, frame_size)
  278. T = sample_data.shape[2]
  279. fig, axes = plt.subplots(6, 6, sharey = True, sharex = True, figsize = (10, 10))
  280. for tt in range(0,T):
  281. for ii in range(0,6):
  282. for jj in range(0,6):
  283. idx_j = jj * 2
  284. axes[ii,jj].imshow(sample_data[ii,idx_j,tt,...], cmap = 'gray', vmin = -1, vmax = 1)
  285. axes[ii,jj].tick_params(left=False,
  286. bottom=False,
  287. labelleft=False,
  288. labelbottom=False)
  289. if ii == 0:
  290. axes[ii,jj].set_title(r'$\alpha : %1.2f$' %(idx_j*0.2), fontsize = fontsize)
  291. fig_array = figure_to_array(fig)
  292. output.write(fig_array)
  293. output.release()
  294. cv2.destroyAllWindows()
  296. def classifier_output_quant(mixed_samples, reference_data, y, network):
  297. """Utility function for quantifying the classifier output accuracy and variability for hallucination data"""
  298. if torch.cuda.is_available():
  299. mixed_samples = mixed_samples.to(torch.cuda.current_device())
  300. reference_data = reference_data.to(torch.cuda.current_device())
  301. y = y.to(torch.cuda.current_device())
  302. classifier_logits = network.classifier(mixed_samples)
  303. reference_logits = network.classifier(reference_data)
  304. class_predictions = torch.argmax(classifier_logits, dim = -1)
  305. accuracy = torch.sum(class_predictions[:,-1] == y)/len(y)
  306. variability = torch.mean(torch.var(classifier_logits, axis = 1))
  308. classifier_corr = torch.corrcoef(classifier_logits.flatten(end_dim = 1).permute(1,0))
  310. reference_corr = torch.corrcoef(reference_logits.flatten(end_dim = 1).permute(1,0))
  312. dist = 1 - torch.corrcoef(torch.stack([classifier_corr.flatten(), reference_corr.flatten()]))[0,1]
  313. return accuracy, variability, dist
  315. def classifier_output_plot(classifier_accuracy, classifier_variability, log_dir):
  316. """Plotting function for the classifier accuracy"""
  317. mixing_constant = torch.arange(0,1.1,0.1)
  318. fig, axes = plt.subplots(1,1, figsize = (1.5,1.5))
  319. axes.scatter(mixing_constant, classifier_accuracy, color = apical_color)
  320. plt.title('Classifier Accuracy')
  321. axes.set_xlabel(r'$\alpha$', fontsize = fontsize)
  322. axes.set_ylabel('Proportion correct', fontsize = fontsize)
  323. axes.set_ylim([0,1])
  324. axes.spines.top.set_visible(False)
  325. axes.spines.right.set_visible(False)
  326. axes.tick_params(axis = 'both', which = 'major', labelsize=fontsize)
  327. axes.tick_params(axis = 'both', which = 'minor', labelsize = fontsize)
  329. plt.tight_layout()
  330. fig.savefig(str(log_dir / "classifier accuracy.pdf"), format = 'pdf')
  332. fig, axes = plt.subplots(1,1, figsize = (1.5,1.5))
  333. axes.scatter(mixing_constant, classifier_variability, color = apical_color)
  334. plt.title('Classifier Output Variability')
  335. axes.set_xlabel(r'$\alpha$', fontsize = fontsize)
  336. axes.set_ylabel('Variability', fontsize = fontsize)
  337. axes.spines.top.set_visible(False)
  338. axes.spines.right.set_visible(False)
  339. axes.tick_params(axis = 'both', which = 'major', labelsize=fontsize)
  340. axes.tick_params(axis = 'both', which = 'minor', labelsize = fontsize)
  342. plt.tight_layout()
  343. fig.savefig(str(log_dir / "classifier variability.pdf"), format = 'pdf')
  346. def dynamic_stim_cond_var(mixed_outputs, reference):
  347. """Utility function for computing the change in stimulus-conditioned variability averaged over a batch of stimuli, for hallucinated network activity"""
  348. var = torch.var(mixed_outputs, dim = 0)
  349. ref_var = torch.var(reference, dim = 0)
  350. delta_var = torch.mean(var - ref_var)
  351. sem_var = torch.std(var - ref_var)/np.sqrt(var.shape[0])
  352. return delta_var, sem_var
  354. def dynamic_across_stim_var(mixed_outputs, inact_mixed_outputs):
  355. """Utility function for computing the change in across-stimulus variability for hallucinated network activity"""
  356. var_ratio_eps = 1e-3
  357. var = torch.var(mixed_outputs[[-1],...], dim = (0,1))
  358. inact_var = torch.var(inact_mixed_outputs[[-1],...], dim = (0,1))
  359. mean_var_ratio = torch.mean((inact_var + var_ratio_eps)/(var + var_ratio_eps))
  360. sem_var_ratio = torch.std((inact_var + var_ratio_eps)/(var + var_ratio_eps))/np.sqrt(var.shape[0])
  362. return mean_var_ratio, sem_var_ratio
  364. def dynamic_stim_cond_var_plot(mean_stimulus_conditioned_variance, sem_stimulus_conditioned_variance, log_dir, indicator = ""):
  365. """Plotting function for quantifying stimulus-conditioned variability"""
  366. #generate plots
  367. fig, axes = plt.subplots(1,1,figsize = (1.5,1.5))
  368. plt.bar(torch.arange(0,12), mean_stimulus_conditioned_variance, yerr = sem_stimulus_conditioned_variance)
  369. plt.xticks(ticks = torch.arange(0,12), labels = [r"$\alpha$ = 0", r"$\alpha$ = 0.1", r"$\alpha$ = 0.2", r"$\alpha$ = 0.3", r"$\alpha$ = 0.4", r"$\alpha$ = 0.5", r"$\alpha$ = 0.6", r"$\alpha$ = 0.7", r"$\alpha$ = 0.8", r"$\alpha$ = 0.9", r"$\alpha$ = 1", "across stim"], rotation = 90, fontsize = fontsize)
  370. plt.title("Dose Dependence of Stimulus-Conditioned Variance", fontsize = fontsize)
  371. axes.spines.top.set_visible(False)
  372. axes.spines.right.set_visible(False)
  373. axes.tick_params(axis = 'both', which = 'major', labelsize=fontsize)
  374. axes.tick_params(axis = 'both', which = 'minor', labelsize = fontsize)
  375. plt.tight_layout()
  376. path = "Delta Dynamic Stimulus Conditioned Variance" + indicator + ".pdf"
  377. plt.savefig(str(log_dir / path), format = 'pdf')
  378. return
  380. def dynamic_across_stim_var_plot(mean_var_ratio, std_var_ratio, log_dir, indicator = ""):
  381. """Plotting function for quantifying across-stimulus variability"""
  382. fig, axes = plt.subplots(1,1,figsize = (1.5,1.5))
  383. plt.errorbar(torch.arange(0,11), mean_var_ratio, yerr = std_var_ratio)
  384. plt.plot(torch.arange(0,11), torch.ones(11), 'k')
  385. plt.xticks(ticks = torch.arange(0,11), labels = [r"$\alpha$ = 0", r"$\alpha$ = 0.1", r"$\alpha$ = 0.2", r"$\alpha$ = 0.3", r"$\alpha$ = 0.4", r"$\alpha$ = 0.5", r"$\alpha$ = 0.6", r"$\alpha$ = 0.7", r"$\alpha$ = 0.8", r"$\alpha$ = 0.9", r"$\alpha$ = 1"], rotation = 90, fontsize = fontsize)
  386. plt.title("Dose Dependence of Across-Stim Variance", fontsize = fontsize)
  387. axes.spines.top.set_visible(False)
  388. axes.spines.right.set_visible(False)
  389. axes.tick_params(axis = 'both', which = 'major', labelsize=fontsize)
  390. axes.tick_params(axis = 'both', which = 'minor', labelsize = fontsize)
  391. plt.tight_layout()
  392. path = "Delta Variance" + indicator + ".pdf"
  393. plt.savefig(str(log_dir / path), format = 'pdf')
  394. return
  396. def dynamic_image_plot(sample_data, log_dir, indicator = ""):
  397. """Plotting function for stimulus-layer hallucination snapshots"""
  398. fig, axes = plt.subplots(6, 11, sharey = True, figsize = (7.5, 3))
  399. fig.suptitle('sample generated image', fontsize = fontsize)
  400. idx = 0
  401. shape = sample_data[idx,...].shape
  402. if shape[0] == 3 and shape[1] == 32:
  403. cifar10 = True
  404. else:
  405. cifar10 = False
  406. for ii in range(0,6):
  407. for jj in range(0,11):
  408. if cifar10:
  409. axes[ii,jj].imshow(cifar10_unnormalization(torch.tensor(sample_data[ii,jj,...].permute(1,2,0))))
  410. else:
  411. axes[ii,jj].imshow(torch.tensor(sample_data[ii,jj,...].permute(1,2,0)), cmap = 'gray', vmin = -1, vmax = 1)
  412. axes[ii,jj].tick_params(left=False,
  413. bottom=False,
  414. labelleft=False,
  415. labelbottom=False)
  416. idx = idx + 1
  417. path = indicator + "_dynamic_images.pdf"
  418. plt.savefig(str(log_dir / path), format = 'pdf')
  419. return
  421. def dynamic_corr_calc(activity):
  422. """Utility function for computing within-layer correlations"""
  423. flat_activity = activity
  424. return torch.corrcoef(flat_activity.T)
  426. def dynamic_corr_comparisons_plot(corr_list, log_dir, indicator = ""):
  427. """Plotting function for comparing correlation matrices across different hallucination levels"""
  428. mixing_constant = np.arange(0,1,0.2)
  429. fig, axes = plt.subplots(1, 11, sharey = True, sharex = True, figsize = (15,1.5))
  430. fig_2, axes_2 = plt.subplots(1, 11, sharey = True, sharex = True, figsize = (15,1.5))
  431. fig_3, axes_3 = plt.subplots(1,1, figsize = (1.5,1.5))
  432. fig.suptitle('Across stimulus correlation matrices', fontsize = fontsize)
  433. K = 20
  434. mixing_constant = np.arange(0,1.1,0.1)
  435. corr_vec = torch.zeros(len(mixing_constant))
  436. for jj in range(0,len(mixing_constant)):
  437. corr_full = corr_list[jj,...]
  438. corr = corr_full[0:K,0:K]
  439. if jj == 0:
  440. corr_0 = corr
  441. corr_0_full = corr_full
  442. im = axes[jj].imshow(corr - torch.eye(*corr.shape), vmin = -1, vmax = 1)
  443. fig.colorbar(im, ax = axes[jj])
  444. axes[jj].set_title(r'$\alpha : %1.2f$' %(jj*0.1), fontsize = fontsize)
  445. axes[jj].tick_params(left=False,
  446. bottom=False,
  447. labelleft=False,
  448. labelbottom=False)
  449. axes_2[jj].scatter(corr_0.flatten(), corr.flatten())
  450. axes_2[jj].set_xlabel(r'$\alpha = 0$ correlation', fontsize = fontsize)
  451. axes_2[jj].set_ylabel(r'$\alpha = %1.2f$ correlation' %(jj*0.1), fontsize = fontsize)
  452. corr_vec[jj] = torch.corrcoef(torch.stack([corr_0_full.flatten(), corr_full.flatten()]))[0,1]
  453. axes_3.scatter(mixing_constant[jj], corr_vec[jj])
  455. path_1 = indicator + "Correlation matrices.pdf"
  456. path_2 = indicator + "Correlation matrix scatterplots.pdf"
  457. fig.savefig(str(log_dir / path_1), format = 'pdf')
  458. fig_2.savefig(str(log_dir / path_2), format = 'pdf')
  460. axes_3.set_ylabel('corr sim')
  461. axes_3.set_title('Dose Dependence of Correlation similarity')
  462. axes_3.set_ylim([0,1])
  463. plt.xticks(ticks = mixing_constant, labels = [r"$\alpha$ = 0", r"$\alpha$ = 0.1", r"$\alpha$ = 0.2", r"$\alpha$ = 0.3", r"$\alpha$ = 0.4", r"$\alpha$ = 0.5", r"$\alpha$ = 0.6", r"$\alpha$ = 0.7", r"$\alpha$ = 0.8", r"$\alpha$ = 0.9", r"$\alpha$ = 1.0"], rotation = 90, fontsize = fontsize)
  464. plt.tight_layout()
  465. path_3 = indicator + "Correlation similarity metric.pdf"
  466. fig_3.savefig(str(log_dir / path_3), format = 'pdf')
  467. return
  469. def cosine_similarity(vec_1, vec_2):
  470. """Utility function for computing cosine similarity"""
  471. norm_1 = vec_1.flatten()
  472. norm_1 = norm_1/torch.linalg.norm(norm_1)
  473. norm_2 = vec_2.flatten()
  474. norm_2 = norm_2/torch.linalg.norm(norm_2)
  476. return torch.dot(norm_1, norm_2)
  478. def explained_var_calc(data, n_components):
  479. """Utility function for computing the proportion explained variance of different principal components"""
  480. pca = PCA(n_components=n_components)
  481. pca.fit(data.flatten(start_dim = 1))
  482. return pca.explained_variance_ratio_
  484. def explained_var_plot(explained_var, log_dir):
  485. """Plotting function for the proportion explained variance for different principal components across different hallucination levels"""
  486. fig, ax = plt.subplots(1,1, figsize = (3, 3))
  487. ax.plot(explained_var[0,:])
  488. ax.plot(explained_var[5,:])
  489. ax.plot(explained_var[-1,:])
  490. ax.set_xlabel('PC #')
  491. ax.set_ylabel('Proportion explained variance')
  492. plt.legend((r'$\alpha = 0$', r'$\alpha = 0.5$', r'$\alpha = 1$'))
  493. plt.tight_layout()
  494. fig.savefig(str(log_dir / "explained variance ratio analysis.pdf"), format = 'pdf')
  496. class DynamicMixedSampler(Callback):
  497. def __init__(self) -> None:
  498. """
  499. The primary callback for generating and analyzing hallucinatory activity in trained networks
  500. """
  501. super().__init__()
  502. self.record = SimRecord(default_factory)
  504. def on_test_batch_end(
  505. self, trainer: Trainer, pl_module: Algorithm, outputs, batch: tuple[Tensor, Tensor], batch_idx: int, dataloader_idx = 0
  506. ) -> None:
  507. self.record.x.append(pl_module.x)
  508. self.record.y.append(pl_module.y)
  509. return
  511. def on_test_end(self, trainer: Trainer, pl_module: Algorithm) -> None:
  512. """Run on a fully trained network at the end of training"""
  513. with torch.inference_mode(False),torch.set_grad_enabled(True):
  514. if trainer is not None:
  515. # Use the Trainer's log dir if we have a trainer. (NOTE: we should always have one,
  516. # except maybe during some unit tests where the DataModule is used by itself.)
  517. log_dir = Path(trainer.log_dir or log_dir)
  519. mixing_constant = np.arange(0,1.1,0.1)
  520. T = 800 #number of simulation timesteps
  521. plasticity_eps = 1e-2 #constant to prevent numerical instability in plasticity calculations
  522. sample_data = torch.zeros(6,11,T, *pl_module.x[0,...].permute(1,2,0).shape)
  524. #Initialize all storage variables
  525. x = pl_module.x
  526. y = pl_module.y
  527. timescale = 0.1
  528. shape = x[0,...].shape
  529. sample_data_im_analysis = torch.zeros(x.shape[0],11, *pl_module.x[0,...].permute(1,2,0).shape)
  530. sample_data_closed_eyes = torch.zeros(6,11,*pl_module.x[0,...].permute(1,2,0).shape)
  531. if shape[0] == 3 and shape[1] == 32:
  532. cifar10 = True
  533. inaturalist = False
  534. mnist = False
  535. elif shape[0] == 3 and shape[1] == 224:
  536. inaturalist = True
  537. cifar10 = False
  538. mnist = False
  539. else:
  540. mnist = True
  541. cifar10 = False
  542. inaturalist = False
  544. classifier_accuracy = torch.zeros(11)
  545. classifier_variability = torch.zeros(11)
  546. classifier_dist = torch.zeros(13)
  549. corr_N = np.prod(pl_module.network.ts[1].output.shape[1::])
  551. corr = torch.zeros(11,corr_N, corr_N)
  552. pc_num = 20
  553. explained_var = torch.zeros(11, pc_num)
  555. mean_stimulus_conditioned_variance = torch.zeros(12)
  556. std_stimulus_conditioned_variance = torch.zeros(12)
  558. mean_var_ratio = torch.zeros(11)
  559. sem_var_ratio = torch.zeros(11)
  561. mean_var_ratio_apical = torch.zeros(11)
  562. sem_var_ratio_apical = torch.zeros(11)
  563. total_apical_plasticity = torch.zeros(11)
  564. total_apical_plasticity_sem = torch.zeros(11)
  565. apical_cosine_sim = torch.zeros(11)
  566. total_basal_plasticity = torch.zeros(11)
  567. total_basal_plasticity_sem = torch.zeros(11)
  568. basal_cosine_sim = torch.zeros(11)
  569. gen_opt, inf_opt, _ = pl_module.optimizers()
  570. if mnist:
  571. multiplier = -1.
  572. else:
  573. multiplier = 0.
  574. if torch.cuda.is_available():
  575. x_closed_eyes = multiplier*torch.ones(pl_module.x.shape, device = torch.cuda.current_device())
  576. else:
  577. x_closed_eyes = multiplier*torch.ones(pl_module.x.shape)
  579. for jj in range(0,11): # loop through hallucination magnitudes
  580. data = x
  581. #Store network activity for layers 0 and 1 while under hallucinatory dynamics
  582. data = pl_module.network.dynamic_mixed_forward(data, T, mixing_constant = 1-mixing_constant[jj], timescale = timescale, idxs = [0,1], mode = pl_module.hallucination_mode)
  584. #Generate plasticity based on hallucinatory network activity
  585. gen_opt.zero_grad()
  586. total_likelihood_gen_rm = - pl_module.network.gen_log_prob(mixed_output = True)
  587. pre_grad_gen = torch.mean(total_likelihood_gen_rm)
  588. pre_grad_gen.backward()
  589. gen_grad_list = []
  590. gen_grad_var_list = []
  591. gen_grad_dim_list = []
  592. gen_cosine_sim = []
  593. if jj == 0:
  594. baseline_grad_list_gen = []
  595. ctr = 0
  597. #Quantify plasticity based on hallucinatory network activity
  598. for param in pl_module.network.gen_group.parameters():
  599. if not(param.grad is None):
  600. if jj == 0:
  601. baseline_grad_list_gen.append(param.grad)
  602. gen_grad_list.append(torch.mean(pl_module.hp.backward_optimizer.lr * torch.abs(param.grad) / (torch.abs(param.data) + plasticity_eps)))
  603. gen_grad_dim_list.append(torch.prod(torch.tensor(param.grad.shape)))
  604. gen_grad_var_list.append(torch.var(pl_module.hp.backward_optimizer.lr * torch.abs(param.grad) / (torch.abs(param.data) + plasticity_eps)))
  605. gen_cosine_sim.append(cosine_similarity(param.grad, baseline_grad_list_gen[ctr]))
  606. ctr += 1
  607. total_apical_plasticity[jj] = torch.mean(torch.tensor(gen_grad_list))
  608. total_gen_param_num = torch.sum(torch.tensor(gen_grad_dim_list))
  609. #have to reweight the variances by the number of parameters in each tensor
  610. total_apical_plasticity_sem[jj] = torch.sum((torch.tensor(gen_grad_dim_list) * torch.tensor(gen_grad_var_list)))/total_gen_param_num / torch.sqrt(total_gen_param_num)
  611. apical_cosine_sim[jj] = torch.mean(torch.tensor(gen_cosine_sim))
  612. inf_opt.zero_grad()
  613. total_likelihood_inf = -pl_module.network.log_prob(mixed_output = True)
  614. pre_grad_inf = torch.mean(total_likelihood_inf)
  615. pre_grad_inf.backward()
  616. inf_grad_list = []
  617. inf_grad_dim_list = []
  618. inf_grad_var_list = []
  619. inf_cosine_sim = []
  620. if jj == 0:
  621. baseline_grad_list_inf = []
  622. ctr = 0
  623. for param in pl_module.network.inf_group.parameters():
  624. if not(param.grad is None):
  625. if jj == 0:
  626. baseline_grad_list_inf.append(param.grad)
  627. inf_grad_list.append(torch.mean(pl_module.hp.forward_optimizer.lr * torch.abs(param.grad) / (torch.abs(param.data) + plasticity_eps)))
  628. inf_grad_dim_list.append(torch.prod(torch.tensor(param.grad.shape)))
  629. inf_grad_var_list.append(torch.var(pl_module.hp.forward_optimizer.lr * torch.abs(param.grad) / (torch.abs(param.data) + plasticity_eps)))
  630. inf_cosine_sim.append(cosine_similarity(param.grad, baseline_grad_list_inf[ctr]))
  631. ctr +=1
  632. total_basal_plasticity[jj] = torch.mean(torch.tensor(inf_grad_list))
  633. total_inf_param_num = torch.sum(torch.tensor(inf_grad_dim_list))
  634. #have to reweight the variances by the number of parameters in each tensor
  636. total_basal_plasticity_sem[jj] = torch.sum((torch.tensor(inf_grad_dim_list) * torch.tensor(inf_grad_var_list)))/total_inf_param_num / torch.sqrt(total_inf_param_num)
  638. basal_cosine_sim[jj] = torch.mean(torch.tensor(inf_cosine_sim))
  640. im_data = data[0].cpu().permute(1,0,3,4,2)
  641. lesion_idx = 0
  642. #generate inactivation data (inactivate highest network layer)
  643. data_inactivation = pl_module.network.dynamic_mixed_forward(x, T, mixing_constant = 1-mixing_constant[jj], timescale = timescale, idxs = [0], lesion_idxs = [lesion_idx], mode = pl_module.hallucination_mode)
  645. #generate apical inactivation data (cut off apical inputs to the stimulus layer)
  646. apical_lesion_idx = len(pl_module.network.gen_ts) - 1
  647. data_apical_inactivation = pl_module.network.dynamic_mixed_forward(x, T, mixing_constant = 1-mixing_constant[jj], timescale = timescale, idxs = [0], apical_lesion_idxs = [apical_lesion_idx], mode = pl_module.hallucination_mode)
  648. im_data_inactivation = data_inactivation[0].cpu().permute(1,0,3,4,2)
  649. im_data_apical_inactivation = data_apical_inactivation[0].cpu().permute(1,0,3,4,2)
  650. data_closed_eyes = pl_module.network.dynamic_mixed_forward(x_closed_eyes, T, mixing_constant = 1-mixing_constant[jj], timescale = timescale, idxs = [0])
  651. im_data_closed_eyes = data_closed_eyes[0].cpu().permute(1,0,3,4,2)
  652. if jj == 0:
  653. class_data_ref = data[1].cpu().permute(1,0,2)
  654. class_data = data[1].cpu().permute(1,0,2)
  655. corr[jj,...] = dynamic_corr_calc(class_data[:,-1,...])
  656. explained_var[jj,:] = torch.from_numpy(explained_var_calc(class_data[:,-1,...], pc_num))
  657. sample_data[:,jj,...] = im_data[0:6,...] #
  658. sample_data_closed_eyes[:,jj,...] = im_data_closed_eyes[0:6,-1,...]
  659. sample_data_im_analysis[:,jj,...] = im_data[:,-1,...]
  660. if cifar10:
  661. sample_data[:,jj,...] = cifar10_unnormalization(sample_data[:,jj,...])
  662. elif inaturalist:
  663. sample_data = sample_data
  664. if jj == 0:
  665. reference_data = im_data.permute(1,0,2,3,4)
  666. if jj == 0:
  667. mean_stimulus_conditioned_variance[-1], std_stimulus_conditioned_variance[-1] = dynamic_stim_cond_var(im_data.permute(1,0,2,3,4)[0,...], reference_data)
  668. mean_stimulus_conditioned_variance[jj], std_stimulus_conditioned_variance[jj] = dynamic_stim_cond_var(im_data.permute(1,0,2,3,4), reference_data)
  669. mean_var_ratio[jj], sem_var_ratio[jj] = dynamic_across_stim_var(im_data.permute(1,0,2,3,4), im_data_inactivation.permute(1,0,2,3,4))
  670. mean_var_ratio_apical[jj], sem_var_ratio_apical[jj]= dynamic_across_stim_var(im_data.permute(1,0,2,3,4), im_data_apical_inactivation.permute(1,0,2,3,4))
  672. classifier_accuracy[jj], classifier_variability[jj], classifier_dist[jj] = classifier_output_quant(class_data, class_data_ref, y, pl_module.network)
  674. if mnist:
  675. sample_data = (sample_data + 1)/2 #now mnist data lies between 0 and 1
  676. sample_data = sample_data.repeat(1,1,1,1,1,3) #convert [28,28,1] shape to [28,28,3] shape
  678. #generate plots based on analyzed data
  679. dynamic_stim_cond_var_plot(mean_stimulus_conditioned_variance, std_stimulus_conditioned_variance, log_dir)
  681. plasticity_quant_plot(total_apical_plasticity, total_apical_plasticity_sem, total_basal_plasticity, total_basal_plasticity_sem, apical_cosine_sim, basal_cosine_sim, log_dir)
  683. explained_var_plot(explained_var, log_dir)
  685. dynamic_across_stim_var_plot(mean_var_ratio, sem_var_ratio, log_dir, indicator = "")
  686. dynamic_across_stim_var_plot(mean_var_ratio_apical, sem_var_ratio_apical, log_dir, indicator = " apical inact")
  688. classifier_output_plot(classifier_accuracy, classifier_variability, log_dir)
  690. dynamic_image_plot(sample_data[:,:,-1,...].permute(0,1,4,2,3), log_dir, indicator = "mixed")
  691. dynamic_image_plot(sample_data_closed_eyes.permute(0,1,4,2,3), log_dir, indicator = "closed_eyes")
  692. dynamic_corr_comparisons_plot(corr, log_dir, indicator = "dynamic_")
  693. dynamic_mixed_samples_pyplot(sample_data[:,:,0:500,...], log_dir) #video functionality. Runtime can be significantly reduced by commenting out this line
  694. return

callbacks.py at commit 40dbd6d, under MIT · at the source

Overview

Authors: Colin Bredenberg1,2, Fabrice Normandin1, Blake Richards1,3, Guillaume Lajoie1,2
ORCID iDs: Colin Bredenberg, Blake Richards, Guillaume Lajoie
  1. Mila - Quebec AI Institute, Montreal, Canada
  2. University of Montreal, Montreal, Canada
  3. McGill University, Montreal, Canada
Institutions: Mila - Quebec Artificial Intelligence Institute (Canada); Université de Montréal (Canada); McGill University (Canada)
Journal: eLife, volume 14, article RP105968
Dates: published online 21 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.7554/elife.105968 · PMID 42011872 · PMCID PMC13099140 · OpenAlex W4411087740
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism)
Methods: Single-unit activity, calcium imaging, Machine learning
Keywords: None
MeSH: Hallucinations*, Hallucinogens*, Neuronal Plasticity*, Dreams, Humans, Models, Neurological, Neural Networks, Computer, Sleep (* major topic)
Topic: Psychedelics and Drug Studies (Clinical Psychology, Psychology), according to OpenAlex
Funding: Arthur B. McDonald Fellowship (566355-2022); Natural Sciences and Engineering Research Council of Canada (RGPIN-2020-05105, RGPAS-2020-00031, RGPIN-2018-04821)
Citations: cited by 1 paper (Europe PMC); 146 references in the paper

Abstract

Classical psychedelics induce complex visual hallucinations in humans, generating percepts that are coherent at a low level, but which have surreal, dream-like qualities at a high level. While there are many hypotheses as to how classical psychedelics could induce these effects, there are no concrete mechanistic models that capture the variety of observed effects in humans, while remaining consistent with the known pharmacological effects of classical psychedelics on neural circuits. In this work, we propose the ‘oneirogen hypothesis,’ which posits that the perceptual effects of classical psychedelics are a result of their pharmacological actions inducing neural activity states that truly are more similar to dream-like states. We simulate classical psychedelics’ effects via manipulating neural network models trained on perceptual tasks with the Wake-Sleep algorithm. This established machine learning algorithm leverages two activity phases: a perceptual phase (wake) where sensory inputs are encoded, and a generative phase (dream) where the network internally generates activity consistent with stimulus-evoked responses. We simulate the action of psychedelics by partially shifting the model to the ‘Sleep’ state, which entails a greater influence of top-down connections, in line with the impact of psychedelics on apical dendrites. The effects resulting from this manipulation capture a number of experimentally observed phenomena, including the emergence of hallucinations, increases in stimulus-conditioned variability, and large increases in synaptic plasticity. We further provide a number of testable predictions which could be used to validate or invalidate our oneirogen hypothesis.

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

Repositories

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

colinbredenberg/oneirogen-hypothesis

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 40dbd6de2ca131ebe291b47fd7ff7ff786a38f34, 11 September 2024
Languages: Python (54)
Size: 87 files, 54 scripts
Software Heritage: archived
Found in: “Data availability”
Holds: README, license file, environment (pyproject.toml, requirements.txt), tests
Not found: CITATION.cff, continuous integration, documentation
Tools: PyTorch (35 files), PyTorch Lightning (10 files), NumPy (5 files), NetworkX (4 files), Matplotlib (1 file), OpenCV (1 file), Pillow (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
56 files
At the source: github.com/colinbredenberg/oneirogen-hypothesis

colinbredenberg/vdvae

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 919a2360c6df9cb429a13570a12deb5cdf647d9b, 6 October 2025
Languages: Python (8), Shell (4), Jupyter (1)
Size: 19 files, 13 scripts
Software Heritage: archived
Found in: “Data availability”
Holds: README, license file, environment (pyproject.toml, uv.lock), 1 notebook
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (8 files), PyTorch (7 files), imageio (2 files), Matplotlib (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
15 files
At the source: github.com/colinbredenberg/vdvae

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;
  • 67 scripts, each with its path and the digest of its content;
  • 8 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

Code for reproducing all results from Wake-Sleep-trained models in this study is available here: https://github.com/colinbredenberg/oneirogen-hypothesis, copy archived at Bredenberg, 2024. Code for reproducing results obtained with pretrained VDVAE models is available here: https://github.com/colinbredenberg/vdvae, copy archived at Bredenberg, 2025.

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

Versions

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

Version 1, 29 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 4 authors, 1 keyword, 8 MeSH terms, 2 funders, 118 references.

Cite

This paper

Bredenberg, C., Normandin, F., Richards, B., & Lajoie, G. (2026). Modeling the hallucinatory effects of classical psychedelics in terms of replay-dependent plasticity mechanisms. eLife, 14, RP105968. https://doi.org/10.7554/elife.105968

BibTeX

@article{bredenberg2026modeling,
author = {Bredenberg, Colin and Normandin, Fabrice and Richards, Blake and Lajoie, Guillaume},
title = {{Modeling the hallucinatory effects of classical psychedelics in terms of replay-dependent plasticity mechanisms}},
journal = {eLife},
year = {2026},
month = apr,
volume = {14},
pages = {RP105968},
publisher = {eLife Sciences Publications, Ltd},
issn = {2050-084X},
doi = {10.7554/elife.105968},
url = {https://doi.org/10.7554/elife.105968},
pmid = {42011872},
pmcid = {PMC13099140}
}

RIS

TY - JOUR
AU - Bredenberg, Colin
AU - Normandin, Fabrice
AU - Richards, Blake
AU - Lajoie, Guillaume
TI - Modeling the hallucinatory effects of classical psychedelics in terms of replay-dependent plasticity mechanisms
T2 - eLife
J2 - eLife
PY - 2026
DA - 2026/04/21
VL - 14
SP - RP105968
SN - 2050-084X
PB - eLife Sciences Publications, Ltd
DO - 10.7554/elife.105968
UR - https://doi.org/10.7554/elife.105968
LA - en
ER -

CSL-JSON

{
"id": "10.7554/elife.105968",
"type": "article-journal",
"title": "Modeling the hallucinatory effects of classical psychedelics in terms of replay-dependent plasticity mechanisms",
"container-title": "eLife",
"author": [
{
"family": "Bredenberg",
"given": "Colin"
},
{
"family": "Normandin",
"given": "Fabrice"
},
{
"family": "Richards",
"given": "Blake"
},
{
"family": "Lajoie",
"given": "Guillaume"
}
],
"container-title-short": "eLife",
"volume": "14",
"page": "RP105968",
"DOI": "10.7554/elife.105968",
"PMID": "42011872",
"PMCID": "PMC13099140",
"ISSN": "2050-084X",
"publisher": "eLife Sciences Publications, Ltd",
"URL": "https://doi.org/10.7554/elife.105968",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
21
]
]
}
}

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.7554/elife.105953 [code]
Top-down feedback in deep neural networks leads to functional differences during audiovisual integration.
Journal: eLife
In common: PyTorch Lightning, Pillow, PyTorch, 3 other tools, 5 references, author Blake Richards
[2] doi:10.1038/s41467-026-74460-8 [code]
Spike-based alignment learning solves the weight transport problem.
Journal: Nature communications
In common: PyTorch, scikit-learn, Matplotlib, 1 other tool, 8 references
[3] doi:10.1371/journal.pcbi.1014164 [code]
'Backpropagation and the brain' realized in cortical error neuron microcircuits.
Journal: PLoS computational biology
In common: PyTorch, Matplotlib, NumPy, 7 references
[4] doi:10.1038/s41467-026-74816-0 [code]
Hierarchical optimization predicts plasticity in the macaque inferior temporal cortex following object training.
Journal: Nature communications
In common: PyTorch, scikit-learn, Matplotlib, 1 other tool, 5 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: imageio, Pillow, PyTorch, 3 other tools, 3 references
[6] doi:10.1038/s41593-026-02232-0 [code]
Entorhinal cortex represents task-relevant remote locations independently of CA1.
Journal: Nature neuroscience
In common: NetworkX, OpenCV, Pillow, 4 other tools, 2 references
[7] doi:10.1371/journal.pcbi.1014263 [code]
MIRAGE: Robust multi-modal architectures translate fMRI-to-image models from vision to mental imagery.
Journal: PLoS computational biology
In common: PyTorch Lightning, imageio, OpenCV, 5 other tools
[8] doi:10.1038/s41467-026-77318-1 [code]
Offline generative network reconfiguration guides insight-like accelerated learning by assimilation into schema in rats.
Journal: Nature communications
In common: scikit-learn, Matplotlib, 6 references
[9] doi:10.7554/elife.108023 [code]
Challenges in replay detection by TDLM in post-encoding resting state.
Journal: eLife
In common: scikit-learn, Matplotlib, NumPy, 5 references
[10] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: PyTorch Lightning, NetworkX, OpenCV, 5 other tools

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.