OSCR

MR-AIV reveals in vivo brain-wide fluid flow with physics-informed AI.

Code ↔ Paper

1 match 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 1 match
  1. [1] § MATERIALS AND METHODS › Magnetic resonance artificial intelligence velocimetry ↔ src/instant_aiv/models/NNpp.py, lines 201–233 · score 0.52 · activation function, weight normalization, connections, network, layers, models

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 · 824 lines · 31 KB · no license · 1 match

  1. # Libraries
  3. import numpy as np
  4. from jax import jit, vmap, grad
  5. import jax.numpy as jnp
  6. from jax.nn import sigmoid
  7. from typing import Tuple
  9. from typing import Tuple, List, Dict, Sequence
  10. import h5py
  11. from instant_aiv.models.metrics import *
  12. from instant_aiv.manage.dataloader import *
  13. import optax
  15. #Initialization
  16. from typing import Tuple
  18. def glorot_normal(in_dim: int, out_dim: int) -> jnp.ndarray:
  19. glorot_stddev = np.sqrt(2.0 / (in_dim + out_dim))
  20. return jnp.array(np.random.normal(loc=0.0, scale=glorot_stddev, size=(in_dim, out_dim)))
  23. def init_params(layers: List[int], initialization_type: str = 'xavier',Network_type: str='mlp',degree: int =5,Use_ResNet: bool =False) -> dict:
  24. def init_adaptive_params():
  25. F = 0.1 * jnp.ones(3 * len(layers) - 1)
  26. A = 0.1 * jnp.ones(3 * len(layers) - 1)
  27. return [{"a0": A[3*i], "a1": A[3*i + 1], "a2": A[3*i + 2],
  28. "f0": F[3*i], "f1": F[3*i + 1], "f2": F[3*i + 2]}
  29. for i in range(len(layers) - 1)]
  30. #Define Models:
  31. def init_layer_mlp(in_dim, out_dim):
  32. if initialization_type == 'xavier':
  33. W = glorot_normal(in_dim, out_dim)
  34. elif initialization_type == 'normal':
  35. W = jnp.array(np.random.normal(size=(in_dim, out_dim)))
  36. b = jnp.zeros(out_dim)
  37. g = jnp.ones(out_dim)
  38. return {"W": W, "b": b, "g": g}
  39. def init_layer_ResNet(in_dim, out_dim):
  40. if initialization_type == 'xavier':
  41. W1 = glorot_normal(in_dim, out_dim)
  42. W2 = glorot_normal(out_dim, out_dim)
  43. W3 = glorot_normal(out_dim, out_dim)
  44. elif initialization_type == 'normal':
  45. W1 = jnp.array(np.random.normal(size=(in_dim, out_dim)))
  46. W2 = jnp.array(np.random.normal(size=(out_dim, out_dim)))
  47. W3 = jnp.array(np.random.normal(size=(out_dim, out_dim)))
  48. b1 = jnp.zeros(out_dim)
  49. b2 = jnp.zeros(out_dim)
  50. b3 = jnp.zeros(out_dim)
  51. g1 = jnp.ones(out_dim)
  52. g2 = jnp.ones(out_dim)
  53. g3 = jnp.ones(out_dim)
  54. alpha=0.0
  55. return {"W": W1, "b": b1, "g": g1,
  56. "W2": W2, "b2": b2, "g2": g2,
  57. 'alpha':alpha}
  58. def init_layer_kan(in_dim, out_dim,degree=degree):
  59. std=1 / (in_dim * (degree + 1))
  60. W =jnp.array(np.random.normal(loc=0.0, scale=std, size=(in_dim, out_dim,degree+1)))
  61. b = jnp.zeros(out_dim)
  62. g = jnp.ones(out_dim)
  63. return {"W": W, "b": b, "g": g}
  64. def init_layer_kan_ResNet(in_dim, out_dim,degree=degree):
  65. std=1 / (in_dim * (degree + 1))
  66. W1 =jnp.array(np.random.normal(loc=0.0, scale=std, size=(in_dim, out_dim,degree+1)))
  67. W2 =jnp.array(np.random.normal(loc=0.0, scale=std, size=(in_dim, out_dim,degree+1)))
  68. b1 = jnp.zeros(out_dim)
  69. b2 = jnp.zeros(out_dim)
  70. g1 = jnp.ones(out_dim)
  71. g2 = jnp.ones(out_dim)
  72. alpha=0.0
  73. return {"W": W1, "b": b1, "g": g1,
  74. "W2": W2, "b2": b2, "g2": g2,
  75. 'alpha':alpha}
  76. #Select model
  77. if Network_type.lower()=='mlp':
  78. if Use_ResNet:
  79. init_layer_params=init_layer_ResNet
  80. else:
  81. init_layer_params=init_layer_mlp
  82. elif Network_type.lower()[:3]=='kan':
  83. if Use_ResNet:
  84. init_layer_params=init_layer_kan_ResNet
  85. else:
  86. init_layer_params=init_layer_kan
  87. else:
  88. print(f'Error: {Network_type.lower()} is not a valid option. The available options are:mlp and kan.')
  89. print(f'Initializing:{Network_type} parameters.')
  90. params = [init_layer_params(layers[i], layers[i + 1]) for i in range(len(layers) - 1)]
  91. U1, b1, g1 = glorot_normal(layers[0], layers[1]), jnp.zeros(layers[1]), jnp.ones(layers[1])
  92. U2, b2, g2 = glorot_normal(layers[0], layers[1]), jnp.zeros(layers[1]), jnp.ones(layers[1])
  94. mMLP_params = [{"U1": U1, "b1": b1, "g1": g1, "U2": U2, "b2": b2, "g2": g2}]
  96. return {
  97. 'params': params,
  98. 'AdaptiveAF': init_adaptive_params(),
  99. 'mMLP': mMLP_params
  100. }
  104. def init_params_res(layers: List[int], initialization_type: str = 'xavier',Network_type: str='mlp',degree: int =5,Use_ResNet: bool =False) -> dict:
  105. def init_adaptive_params():
  106. F = 0.1 * jnp.ones(3 * len(layers) - 1)
  107. A = 0.1 * jnp.ones(3 * len(layers) - 1)
  108. return [{"a0": A[3*i], "a1": A[3*i + 1], "a2": A[3*i + 2],
  109. "f0": F[3*i], "f1": F[3*i + 1], "f2": F[3*i + 2]}
  110. for i in range(len(layers) - 1)]
  112. def init_layer_params(in_dim, out_dim):
  113. if initialization_type == 'xavier':
  114. W1 = glorot_normal(in_dim, out_dim)
  115. W2 = glorot_normal(out_dim, out_dim)
  116. W3 = glorot_normal(out_dim, out_dim)
  117. elif initialization_type == 'normal':
  118. W1 = jnp.array(np.random.normal(size=(in_dim, out_dim)))
  119. W2 = jnp.array(np.random.normal(size=(out_dim, out_dim)))
  120. W3 = jnp.array(np.random.normal(size=(out_dim, out_dim)))
  121. b1 = jnp.zeros(out_dim)
  122. b2 = jnp.zeros(out_dim)
  123. b3 = jnp.zeros(out_dim)
  124. g1 = jnp.ones(out_dim)
  125. g2 = jnp.ones(out_dim)
  126. g3 = jnp.ones(out_dim)
  127. alpha=0.0
  128. return {"W": W1, "b": b1, "g": g1,
  129. "W2": W2, "b2": b2, "g2": g2,
  130. 'alpha':alpha}
  132. params = [init_layer_params(layers[i], layers[i + 1]) for i in range(len(layers) - 1)]
  134. U1, b1, g1 = glorot_normal(layers[0], layers[1]), jnp.zeros(layers[1]), jnp.ones(layers[1])
  135. U2, b2, g2 = glorot_normal(layers[0], layers[1]), jnp.zeros(layers[1]), jnp.ones(layers[1])
  137. mMLP_params = [{"U1": U1, "b1": b1, "g1": g1, "U2": U2, "b2": b2, "g2": g2}]
  139. return {
  140. 'params': params,
  141. 'AdaptiveAF': init_adaptive_params(),
  142. 'mMLP': mMLP_params
  143. }
  146. def init_params_dict(layer_dict, initialization,Use_ResNet=False,Network_type='mlp',degree=5):
  147. print(f'You selected: Network {Network_type} with degree(if KAN) {degree}, initialization {initialization},Use_ResNet {Use_ResNet}')
  148. if Network_type.lower()=='mlp':
  149. if Use_ResNet:
  150. init_function=init_params_res
  151. else:
  152. init_function=init_params
  153. elif Network_type[:3].lower()=='kan':
  154. init_function=init_params
  155. initialized_params = {}
  156. for key, layer_structure in layer_dict.items():
  157. # Initialize parameters for each key
  158. params = init_function(layer_structure,
  159. initialization_type=initialization.lower(),
  160. Network_type=Network_type,
  161. degree=degree,
  162. Use_ResNet=Use_ResNet)
  164. # Store in the dictionary
  165. initialized_params[key] = params
  167. return initialized_params
  172. def FCN(params, X_in, M1, M2, activation_fn, norm_fn):
  173. """
  174. Fully Connected Network (FCN) with a given normalization and activation function.
  176. Parameters:
  177. - params: Dictionary containing parameters of the neural network layers.
  178. - X_in: Input tensor to the network.
  179. - M1, M2: Parameters for normalization function.
  180. - activation_fn: Callable activation function.
  181. - norm_fn: Callable normalization function.
  183. Returns:
  184. - Output tensor from the network.
  185. """
  187. params_N = params["params"]
  188. inputs = norm_fn(X_in, M1, M2)
  190. for layer in params_N[:-1]:
  191. outputs = activation_fn(jnp.dot(inputs, layer["W"]) + layer["b"])
  192. inputs = outputs
  194. W = params_N[-1]["W"]
  195. b = params_N[-1]["b"]
  196. outputs = jnp.dot(inputs, W) + b
  198. return outputs
  201. def FCN_WN(params, X_in, M1, M2, activation, norm_fn):
  202. """
  203. Fully Connected Network (FCN) with Weight Normalization.
  205. Parameters:
  206. - params: Dictionary containing parameters of the neural network layers.
  207. - X_in: Input tensor to the network.
  208. - M1, M2: Parameters for normalization function.
  209. - activation: Callable activation function.
  210. - norm_fn: Callable normalization function.
  212. Returns:
  213. - Output tensor from the network.
  214. """
  216. # Normalize the input
  217. H = norm_fn(X_in, M1, M2)
  219. # Iterate through the layers
  220. for i, layer_params in enumerate(params["params"]):
  221. W, b, g = layer_params["W"], layer_params["b"], layer_params["g"]
  223. # Weight normalization
  224. V = W / jnp.linalg.norm(W, axis=0, keepdims=True)
  226. # Linear transformation
  227. H = g * jnp.matmul(H, V) + b
  229. # Apply activation function for all layers except the last one
  230. if i != len(params["params"]) - 1:
  231. H = activation(H)
  233. return H
  236. def FCN_WN_MMLP(params, X_in, M1, M2, activation, norm_fn):
  237. """
  238. Fully Connected Network (FCN) with Weight Normalization and Modified MLP (MMLP) transformations.
  240. Parameters:
  241. - params: Dictionary containing parameters of the neural network layers and MMLP parameters.
  242. - X_in: Input tensor to the network.
  243. - M1, M2: Parameters for normalization function.
  244. - activation: Callable activation function.
  245. - norm_fn: Callable normalization function.
  247. Returns:
  248. - Output tensor from the network.
  249. """
  251. # Normalize the input
  252. H = norm_fn(X_in, M1, M2)
  254. # Unpack MMLP parameters and apply weight normalization
  255. mMLP_params = params["mMLP"][0]
  256. U1, U2, b1, b2, g1, g2 = (mMLP_params[key] for key in ["U1", "U2", "b1", "b2", "g1", "g2"])
  257. U1_norm, U2_norm = U1 / jnp.linalg.norm(U1, axis=0, keepdims=True), U2 / jnp.linalg.norm(U2, axis=0, keepdims=True)
  259. # Calculate U and V transformations
  260. U = activation(g1 * jnp.dot(H, U1_norm) + b1)
  261. V = activation(g2 * jnp.dot(H, U2_norm) + b2)
  263. # Iterate through the layers
  264. for idx, layer in enumerate(params["params"][:-1]):
  265. W, b, g = layer["W"], layer["b"], layer["g"]
  267. # Apply weight normalization
  268. W_norm = W / jnp.linalg.norm(W, axis=0, keepdims=True)
  270. # Compute activations and apply MMLP combination step
  271. H = activation(g * jnp.dot(H, W_norm) + b)
  272. H = jnp.multiply(H, U) + jnp.multiply(1 - H, V)
  274. # Process the last layer
  275. W, b, g = params["params"][-1]["W"], params["params"][-1]["b"], params["params"][-1]["g"]
  276. W_norm = W / jnp.linalg.norm(W, axis=0, keepdims=True)
  277. H = g * jnp.dot(H, W_norm) + b
  279. return H
  283. def FCN_MMLP(params, X_in, M1, M2, activation, norm_fn):
  284. """
  285. Fully Connected Network (FCN) with Modified MLP (MMLP) transformations.
  287. Parameters:
  288. - params: Dictionary containing parameters of the neural network layers and MMLP parameters.
  289. - X_in: Input tensor to the network.
  290. - M1, M2: Parameters for normalization function.
  291. - activation: Callable activation function.
  292. - norm_fn: Callable normalization function.
  294. Returns:
  295. - Output tensor from the network.
  296. """
  298. # Normalize the input
  299. inputs = norm_fn(X_in, M1, M2)
  301. # Unpack MMLP parameters
  302. mMLP_params = params["mMLP"][0]
  303. U1, U2, b1, b2 = mMLP_params["U1"], mMLP_params["U2"], mMLP_params["b1"], mMLP_params["b2"]
  305. # Calculate U and V transformations
  306. U = activation(jnp.dot(inputs, U1) + b1)
  307. V = activation(jnp.dot(inputs, U2) + b2)
  309. # Iterate through all layers except the last
  310. for layer in params["params"][:-1]:
  311. W, b = layer["W"], layer["b"]
  313. # Compute activations
  314. act_values = activation(jnp.dot(inputs, W) + b)
  316. # MMLP combination step
  317. inputs = jnp.multiply(act_values, U) + jnp.multiply(1 - act_values, V)
  319. # Compute output from the last layer
  320. W, b = params["params"][-1]["W"], params["params"][-1]["b"]
  321. outputs = jnp.dot(inputs, W) + b
  323. return outputs
  326. # Save Resuls
  327. def save_list(Loss,path,name='loss-'):
  328. filename=path+name+".npy"
  329. np.save(filename, np.array(Loss))
  331. def save_MLP_params(params: List[Dict[str, np.ndarray]], save_path,WN=False,Mod_MLP=False):
  332. with h5py.File(save_path, "w") as f:
  333. for layer_idx, layer_params in enumerate(params):
  334. layer_group = f.create_group(f"Layer_{layer_idx/2.0:.2f}")
  335. if WN:
  336. if Mod_MLP:
  337. W, b, g= layer_params.values()
  338. layer_group.create_dataset("W", shape=W.shape, dtype=np.float32, data=W)
  339. layer_group.create_dataset("b", shape=b.shape, dtype=np.float32, data=b)
  340. layer_group.create_dataset("g", shape=g.shape, dtype=np.float32, data=g)
  341. else:
  342. W, b, g= layer_params.values()
  343. layer_group.create_dataset("W", shape=W.shape, dtype=np.float32, data=W)
  344. layer_group.create_dataset("b", shape=b.shape, dtype=np.float32, data=b)
  345. layer_group.create_dataset("g", shape=g.shape, dtype=np.float32, data=g)
  346. else:
  347. W, b = layer_params.values()
  348. layer_group.create_dataset("W", shape=W.shape, dtype=np.float32, data=W)
  349. layer_group.create_dataset("b", shape=b.shape, dtype=np.float32, data=b)
  351. def read_params(filename,WN=False):
  352. data = h5py.File(filename, 'r')
  353. recover_params=[]
  354. for layer in data.keys() :
  355. if WN:
  356. stored={'W':data[layer]['W'][:],'b': data[layer]['b'][:],'g': data[layer]['g'][:]}
  357. else:
  358. stored={'W':data[layer]['W'][:],'b': data[layer]['b'][:]}
  359. recover_params.append(stored)
  360. return recover_params
  365. def select_model(WN=False, Mod_MLP=False,Use_ResNet=False,Adaptive=False,Light=False,Network_type='mlp',degree=5):
  366. if Network_type.lower()=='mlp':
  367. model_map = {
  368. (True, True,False, False, False): FCN_WN_MMLP,
  369. (True, False,False, False, False): FCN_WN,
  370. (False, True,False, False, False): FCN_MMLP,
  371. (False, False,False, False, False): FCN,
  372. (False, False,True, False, False): ResNet,
  373. (False, False,True, False, True): ResNet_light,
  374. (True, False,True, False, False): WN_ResNet,
  375. (True, False,True, False, True): WN_ResNet_light,
  376. (True, False,True, True, False): WN_ResNet_adaptive,
  377. }
  378. return model_map[(WN, Mod_MLP,Use_ResNet,Adaptive,Light)]
  379. elif Network_type.lower()=='kan':
  380. if degree==3:
  381. return KAN_Net3
  382. elif degree==5:
  383. if Use_ResNet:
  384. return KAN5_ResNet
  385. else:
  386. return KAN_Net5
  387. elif degree==7:
  388. return KAN_Net7
  389. elif degree==9:
  390. return KAN_Net9
  391. elif degree==11:
  392. return KAN_Net11
  393. else:
  394. return KAN_Net
  395. elif Network_type.lower()=='kan_theta':
  396. return KAN_Net_theta
  398. def initialize_optimizer(lr0, decay_rate, lrf, decay_step, T_e,optimizer_type='Adam',weight_decay=1e-5):
  399. print('Optimizer',optimizer_type.lower())
  400. if optimizer_type.lower()=='adam':
  401. if decay_rate == 0 or lrf == lr0:
  402. print('No decay')
  403. return optax.adam(lr0), decay_step
  404. else:
  405. if decay_step == 0:
  406. decay_step = T_e * np.log(decay_rate) / np.log(lrf / lr0)
  407. print(f'The decay step will be {decay_step}')
  408. return optax.adam(optax.exponential_decay(lr0, decay_step, decay_rate,)),decay_step
  409. elif optimizer_type.lower()=='adamw':
  410. print('Weight decay:',weight_decay)
  411. if decay_rate == 0 or lrf == lr0:
  412. print('No decay')
  413. return optax.adamw(learning_rate=lr0, weight_decay=weight_decay), decay_step
  415. else:
  416. if decay_step == 0:
  417. decay_step = T_e * np.log(decay_rate) / np.log(lrf / lr0)
  418. print(f'The decay step will be {decay_step}')
  419. # Use adamw with the specified learning rate schedule
  420. return optax.adamw(optax.exponential_decay(lr0, decay_step, decay_rate), weight_decay=weight_decay), decay_step
  421. elif optimizer_type.lower()=='lion':
  422. if decay_rate == 0 or lrf == lr0:
  423. weight_decay=weight_decay*3
  424. print('No decay')
  425. return optax.lion(learning_rate=lr0, weight_decay=weight_decay), decay_step
  426. else:
  427. if decay_step == 0:
  428. weight_decay=weight_decay*3
  429. decay_step = T_e * np.log(decay_rate) / np.log(lrf / lr0)
  430. print(f'The decay step will be {decay_step}')
  431. # Use adamw with the specified learning rate schedule
  432. return optax.lion(optax.exponential_decay(lr0, decay_step, decay_rate), weight_decay=weight_decay), decay_step
  434. def load_params_dict(result_path, dataset_name, layer_dict, initialization, type='Test',Use_ResNet=False):
  435. loaded_params = {}
  436. for key in layer_dict.keys():
  437. # Construct the file path
  438. file_path = f"{result_path}{dataset_name}-{type}_params_{key}.h5"
  440. # Read parameters from the file
  441. raw_params = read_all_params(file_path)[0]
  443. # Initialize a test parameter set for getting lengths
  444. test_params = init_params(layer_dict[key], initialization_type=initialization.lower())
  445. params_length = len(test_params['params'])
  446. params_length_AF = len(test_params['AdaptiveAF'])
  448. # Reconstruct the parameters
  449. reconstructed_params = reconstruct_params(raw_params, params_length, params_length_AF,Use_ResNet)
  451. # Store in the dictionary
  452. loaded_params[key] = reconstructed_params
  454. return loaded_params
  456. def save_params_dict(params,result_path,dataset_name,type='Test',Use_ResNet=False):
  457. # Assuming 'result_path' and 'dataset_name' are defined elsewhere in your code
  458. for key, params in params.items():
  459. # Construct the file name for each set of parameters
  460. output_path = f"{result_path}{dataset_name}-{type}_params_{key}.h5"
  462. # Extract arrays from params
  463. params_to_save = [extract_arrays_from_params(params,Use_ResNet)]
  464. # Save the parameters
  465. save_all_params(params_to_save, output_path)
  466. print(f'Params {key} have been saved!')
  469. def transfer_params(params_s,params_t,levels=[0,1,2]):
  470. for level in levels:
  471. params_t['params'][level]=params_s['params'][level]
  472. return params_t
  473. def L2_regularization(params,beta=0.001):
  474. Loss_L2=0
  475. for param in params:
  476. Loss_L2=jnp.mean(param['W']**2)+Loss_L2
  477. return beta*Loss_L2
  478. def L1_regularization(params,beta=0.001):
  479. Loss_L2=0
  480. for param in params:
  481. Loss_L2=jnp.abs(jnp.mean(param['W']))+Loss_L2
  482. return beta*Loss_L2
  483. def L2_regularization_ResNet(params,beta=0.001):
  484. Loss_L2=0
  485. for param in params:
  486. Loss_L2=jnp.sum(param['W']**2)+jnp.sum(param['W2']**2)+Loss_L2
  487. return beta*Loss_L2
  488. # RESNET ARCHITECTURES
  489. def ResNet(params, X_in, M1, M2, activation_fn, norm_fn):
  490. def linear_layer(H,layer_params,W_key="W",b_key="b"):
  491. W, b= layer_params[W_key], layer_params[b_key]
  492. H= jnp.dot(H,W) + b
  493. return H
  494. params_N = params["params"]
  495. inputs = norm_fn(X_in, M1, M2)
  496. layer_params=params_N[0]
  497. inputs=activation_fn(linear_layer(inputs,layer_params,W_key="W",b_key="b"))
  498. for ly in range(1,len(params_N[:-1])):
  499. layer_params=params_N[ly]
  500. g= activation_fn(linear_layer(inputs,layer_params,W_key="W",b_key="b"))
  501. h= linear_layer(g,layer_params,W_key="W2",b_key="b2")
  502. inputs= activation_fn(h+inputs)
  503. outputs = jnp.dot(inputs, params_N[-1]["W"]) + params_N[-1]["b"]
  505. return outputs
  506. def ResNet_light(params, X_in, M1, M2, activation_fn, norm_fn):
  507. def linear_layer(H,layer_params,W_key="W",b_key="b"):
  508. W, b= layer_params[W_key], layer_params[b_key]
  509. H= jnp.dot(H,W) + b
  510. return H
  511. params_N = params["params"]
  512. inputs = norm_fn(X_in, M1, M2)
  513. layer_params=params_N[0]
  514. inputs=activation_fn(linear_layer(inputs,layer_params,W_key="W",b_key="b"))
  515. inputs0=jnp.copy(inputs)
  516. for ly in range(1,len(params_N[:-2])):
  517. layer_params=params_N[ly]
  518. g= activation_fn(linear_layer(inputs,layer_params,W_key="W",b_key="b"))
  519. h= linear_layer(g,layer_params,W_key="W2",b_key="b2")
  520. inputs= activation_fn(h)
  521. layer_params=params_N[-2]
  522. inputs=activation_fn(linear_layer(inputs+inputs0,layer_params,W_key="W",b_key="b"))
  523. layer_params=params_N[-1]
  524. outputs=activation_fn(linear_layer(inputs,layer_params,W_key="W",b_key="b"))
  526. return outputs
  527. def WN_ResNet(params, X_in, M1, M2, activation, norm_fn):
  528. def linear_layer(H,layer_params,W_key="W",b_key="b",g_key="g"):
  529. W, b, g = layer_params[W_key], layer_params[b_key], layer_params[g_key]
  530. # Weight normalization
  531. V = W / jnp.linalg.norm(W, axis=0, keepdims=True)
  532. # Linear transformation
  533. H = g * jnp.matmul(H, V) + b
  534. return H
  535. params_N = params["params"]
  536. # Normalize the input
  537. H = norm_fn(X_in, M1, M2)
  538. # Encoder Layer
  539. H = activation(linear_layer(H,params_N[0],W_key="W",b_key="b",g_key="g"))
  540. # Iterate through the layers
  541. for i in range(1,len(params_N[:-1])):
  542. layer_params=params_N[i]
  543. F=activation(linear_layer(H,layer_params,W_key="W",b_key="b",g_key="g"))
  544. G=linear_layer(F,layer_params,W_key="W2",b_key="b2",g_key="g2")
  545. H=activation(G+H)
  546. H=linear_layer(H,params_N[-1],W_key="W",b_key="b",g_key="g")
  547. return H
  548. def WN_ResNet_adaptive(params, X_in, M1, M2, activation, norm_fn):
  549. def linear_layer(H,layer_params,W_key="W",b_key="b",g_key="g"):
  550. W, b, g = layer_params[W_key], layer_params[b_key], layer_params[g_key]
  551. # Weight normalization
  552. V = W / jnp.linalg.norm(W, axis=0, keepdims=True)
  553. # Linear transformation
  554. H = g * jnp.matmul(H, V) + b
  555. return H
  556. params_N = params["params"]
  557. # Normalize the input
  558. H = norm_fn(X_in, M1, M2)
  559. # Encoder Layer
  560. H = activation(linear_layer(H,params_N[0],W_key="W",b_key="b",g_key="g"))
  561. # Iterate through the layers
  562. for i in range(1,len(params_N[:-1])):
  563. layer_params=params_N[i]
  564. F=activation(linear_layer(H,layer_params,W_key="W",b_key="b",g_key="g"))
  565. G=linear_layer(F,layer_params,W_key="W2",b_key="b2",g_key="g2")
  566. H=activation(layer_params["alpha"]*G+(1-layer_params["alpha"])*H)
  567. H=linear_layer(H,params_N[-1],W_key="W",b_key="b",g_key="g")
  568. return H
  570. def WN_ResNet_light(params, X_in, M1, M2, activation, norm_fn):
  571. def linear_layer(H,layer_params,W_key="W",b_key="b",g_key="g"):
  572. W, b, g = layer_params[W_key], layer_params[b_key], layer_params[g_key]
  573. # Weight normalization
  574. V = W / jnp.linalg.norm(W, axis=0, keepdims=True)
  575. # Linear transformation
  576. H = g * jnp.matmul(H, V) + b
  577. return H
  578. params_N = params["params"]
  579. # Normalize the input
  580. H = norm_fn(X_in, M1, M2)
  581. # Encoder Layer
  582. H = activation(linear_layer(H,params_N[0],W_key="W",b_key="b",g_key="g"))
  583. H0=jnp.copy(H)
  584. # Iterate through the layers
  585. for i in range(1,len(params_N[:-2])):
  586. layer_params=params_N[i]
  587. F=activation(linear_layer(H,layer_params,W_key="W",b_key="b",g_key="g"))
  588. G=linear_layer(F,layer_params,W_key="W2",b_key="b2",g_key="g2")
  589. H=activation(G)
  590. H=activation(linear_layer(H+H0,params_N[-2],W_key="W",b_key="b",g_key="g"))
  591. H=linear_layer(H,params_N[-1],W_key="W",b_key="b",g_key="g")
  592. return H
  594. def KAN_Net3(params, X_in, M1, M2, activation, norm_fn):
  595. def Cheby_KAN_layer3(x,layer_params,expanded_arr=[]):
  596. # Read chebyshev coefficients:
  597. cheby_coeffs= layer_params["W"]
  598. inputdim=cheby_coeffs.shape[0]
  599. outdim=cheby_coeffs.shape[1]
  600. # Normalize
  601. x = activation(x)
  602. # Reshape
  603. x = x.reshape((-1, inputdim, 1))
  604. x=jnp.stack((T0(x),
  605. T1(x),
  606. T2(x),
  607. T3(x)),axis=2)# Discard dummy dimension
  608. # Compute the Chebyshev interpolation
  609. x = jnp.einsum("bid0,iod->bo", x, cheby_coeffs) # shape = (batch_size, output_dim)
  610. # Remove extra dimension
  611. x= jnp.reshape(x, (outdim,))
  612. return x
  613. #Define params
  614. params_N = params["params"]
  615. #Normalize inputs
  616. x = norm_fn(X_in, M1, M2)
  617. for ly in range(len(params_N)):
  618. layer_params=params_N[ly]
  619. x=Cheby_KAN_layer3(x,layer_params)
  620. return x
  623. def KAN_Net5(params, X_in, M1, M2, activation, norm_fn):
  624. def Cheby_KAN_layer5(x,layer_params,expanded_arr=[]):
  625. # Read chebyshev coefficients:
  626. cheby_coeffs= layer_params["W"]
  627. inputdim=cheby_coeffs.shape[0]
  628. outdim=cheby_coeffs.shape[1]
  629. # Normalize
  630. x = activation(x)
  631. # Reshape
  632. x = x.reshape((-1, inputdim, 1))
  633. x=jnp.stack((T0(x),
  634. T1(x),
  635. T2(x),
  636. T3(x),
  637. T4(x),
  638. T5(x)),axis=2)# Discard dummy dimension
  639. # Compute the Chebyshev interpolation
  640. x = jnp.einsum("bid0,iod->bo", x, cheby_coeffs) # shape = (batch_size, output_dim)
  641. # Remove extra dimension
  642. x= jnp.reshape(x, (outdim,))
  643. return x
  644. #Define params
  645. params_N = params["params"]
  646. #Normalize inputs
  647. x = norm_fn(X_in, M1, M2)
  648. for ly in range(len(params_N)):
  649. layer_params=params_N[ly]
  650. x=Cheby_KAN_layer5(x,layer_params)
  651. return x
  654. def KAN_Net7(params, X_in, M1, M2, activation, norm_fn):
  655. def Cheby_KAN_layer7(x,layer_params,expanded_arr=[]):
  656. # Read chebyshev coefficients:
  657. cheby_coeffs= layer_params["W"]
  658. inputdim=cheby_coeffs.shape[0]
  659. outdim=cheby_coeffs.shape[1]
  660. # Normalize
  661. x = activation(x)
  662. # Reshape
  663. x = x.reshape((-1, inputdim, 1))
  664. x=jnp.stack((T0(x),
  665. T1(x),
  666. T2(x),
  667. T3(x),
  668. T4(x),
  669. T5(x),
  670. T6(x),
  671. T7(x)),axis=2)# Discard dummy dimension
  672. # Compute the Chebyshev interpolation
  673. x = jnp.einsum("bid0,iod->bo", x, cheby_coeffs) # shape = (batch_size, output_dim)
  674. # Remove extra dimension
  675. x= jnp.reshape(x, (outdim,))
  676. return x
  677. #Define params
  678. params_N = params["params"]
  679. #Normalize inputs
  680. x = norm_fn(X_in, M1, M2)
  681. for ly in range(len(params_N)):
  682. layer_params=params_N[ly]
  683. x=Cheby_KAN_layer7(x,layer_params)
  684. return x
  687. def KAN_Net9(params, X_in, M1, M2, activation, norm_fn):
  688. def Cheby_KAN_layer9(x,layer_params,expanded_arr=[]):
  689. # Read chebyshev coefficients:
  690. cheby_coeffs= layer_params["W"]
  691. inputdim=cheby_coeffs.shape[0]
  692. outdim=cheby_coeffs.shape[1]
  693. # Normalize
  694. x = activation(x)
  695. # Reshape
  696. x = x.reshape((-1, inputdim, 1))
  697. x=jnp.stack((T0(x),
  698. T1(x),
  699. T2(x),
  700. T3(x),
  701. T4(x),
  702. T5(x),
  703. T6(x),
  704. T7(x),
  705. T8(x),
  706. T9(x)),axis=2)# Discard dummy dimension
  707. # Compute the Chebyshev interpolation
  708. x = jnp.einsum("bid0,iod->bo", x, cheby_coeffs) # shape = (batch_size, output_dim)
  709. # Remove extra dimension
  710. x= jnp.reshape(x, (outdim,))
  711. return x
  712. #Define params
  713. params_N = params["params"]
  714. #Normalize inputs
  715. x = norm_fn(X_in, M1, M2)
  716. for ly in range(len(params_N)):
  717. layer_params=params_N[ly]
  718. x=Cheby_KAN_layer9(x,layer_params)
  719. return x
  721. def KAN_Net11(params, X_in, M1, M2, activation, norm_fn):
  722. def Cheby_KAN_layer11(x,layer_params,expanded_arr=[]):
  723. # Read chebyshev coefficients:
  724. cheby_coeffs= layer_params["W"]
  725. inputdim=cheby_coeffs.shape[0]
  726. outdim=cheby_coeffs.shape[1]
  727. # Normalize
  728. x = activation(x)
  729. # Reshape
  730. x = x.reshape((-1, inputdim, 1))
  731. x=jnp.stack((T0(x),
  732. T1(x),
  733. T2(x),
  734. T3(x),
  735. T4(x),
  736. T5(x),
  737. T6(x),
  738. T7(x),
  739. T8(x),
  740. T9(x),
  741. T10(x),
  742. T11(x)),axis=2)# Discard dummy dimension
  743. # Compute the Chebyshev interpolation
  744. x = jnp.einsum("bid0,iod->bo", x, cheby_coeffs) # shape = (batch_size, output_dim)
  745. # Remove extra dimension
  746. x= jnp.reshape(x, (outdim,))
  747. return x
  748. #Define params
  749. params_N = params["params"]
  750. #Normalize inputs
  751. x = norm_fn(X_in, M1, M2)
  752. for ly in range(len(params_N)):
  753. layer_params=params_N[ly]
  754. x=Cheby_KAN_layer11(x,layer_params)
  755. return x
  756. # WN KAN
  757. def WN_KAN_Net5(params, X_in, M1, M2, activation, norm_fn):
  758. def Cheby_KAN_layer5(x,layer_params,expanded_arr=[]):
  759. # Read chebyshev coefficients and other params:
  760. cheby_coeffs= layer_params["W"]
  761. g= layer_params["g"]
  762. b= layer_params["b"]
  763. # Normalize
  764. cheby_coeffs= cheby_coeffs / jnp.linalg.norm(cheby_coeffs, axis=0, keepdims=True)
  765. inputdim=cheby_coeffs.shape[0]
  766. outdim=cheby_coeffs.shape[1]
  767. # Normalize
  768. x = activation(x)
  769. # Reshape
  770. x = x.reshape((-1, inputdim, 1))
  771. x=jnp.stack((T0(x),
  772. T1(x),
  773. T2(x),
  774. T3(x),
  775. T4(x),
  776. T5(x)),axis=2)# Discard dummy dimension
  777. # Compute the Chebyshev interpolation
  778. x = jnp.einsum("bid0,iod->bo", x, cheby_coeffs) # shape = (batch_size, output_dim)
  779. # Remove extra dimension
  780. x= jnp.reshape(x, (outdim,))
  781. return g * x+b
  782. #Define params
  783. params_N = params["params"]
  784. #Normalize inputs
  785. x = norm_fn(X_in, M1, M2)
  786. for ly in range(len(params_N)):
  787. layer_params=params_N[ly]
  788. x=Cheby_KAN_layer5(x,layer_params)
  789. return x
  790. def KAN5_ResNet(params, X_in, M1, M2, activation, norm_fn):
  791. def Cheby_KAN_layer5(x,layer_params,W_key):
  792. # Read chebyshev coefficients:
  793. cheby_coeffs= layer_params[W_key]
  794. inputdim=cheby_coeffs.shape[0]
  795. outdim=cheby_coeffs.shape[1]
  796. # Normalize
  797. x = activation(x)
  798. # Reshape
  799. x = x.reshape((-1, inputdim, 1))
  800. x=jnp.stack((T0(x),
  801. T1(x),
  802. T2(x),
  803. T3(x),
  804. T4(x),
  805. T5(x)),axis=2)# Discard dummy dimension
  806. # Compute the Chebyshev interpolation
  807. x = jnp.einsum("bid0,iod->bo", x, cheby_coeffs) # shape = (batch_size, output_dim)
  808. # Remove extra dimension
  809. x= jnp.reshape(x, (outdim,))
  810. return x
  811. params_N = params["params"]
  812. inputs = norm_fn(X_in, M1, M2)
  813. layer_params=params_N[0]
  814. inputs=Cheby_KAN_layer5(inputs,layer_params,W_key="W")
  815. for ly in range(1,len(params_N[:-1])):
  816. layer_params=params_N[ly]
  817. g= Cheby_KAN_layer5(inputs,layer_params,W_key="W")
  818. h= Cheby_KAN_layer5(g,layer_params,W_key="W2")
  819. inputs= h+inputs
  820. layer_params=params_N[-1]
  821. inputs=Cheby_KAN_layer5(inputs,layer_params,W_key="W")
  822. return inputs

NNpp.py at commit f242e08, no license · at the source

Overview

Authors: Juan Diego Toscano1, Yisen Guo2, Zhibo Wang3, Mohammad Vaezi2, Yuki Mori4, George Em Karniadakis1, Kimberly A. S. Boster2, Douglas H. Kelley2
ORCID iDs: Juan Diego Toscano, Yisen Guo, Zhibo Wang, Mohammad Vaezi, Yuki Mori, George Em Karniadakis, Kimberly A. S. Boster, Douglas H. Kelley
  1. Division of Applied Mathematics, Brown University, Providence, RI 02912, USA
  2. Department of Mechanical Engineering, University of Rochester, Rochester, NY 14627, USA
  3. School of Engineering, Brown University, Providence, RI 02912, USA
  4. Center for Translational Neuromedicine, University of Copenhagen, Copenhagen 2200, Denmark
Institutions: Brown University (United States); University of Rochester (United States); University of Copenhagen (Denmark)
Journal: Science advances, volume 12, issue 22, article eaeb0404
Dates: received 30 July 2025; accepted 20 April 2026; published online 27 May 2026; in print May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1126/sciadv.aeb0404 · PMID 42202031 · PMCID PMC13215179 · OpenAlex W7162502040
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), systems (subfield)
Methods: Connectivity, fMRI & imaging, Physiology & signal measures
MeSH: Brain*, Magnetic Resonance Imaging*, Rheology*, Animals, Humans, Hydrodynamics (* major topic)
Journal subjects: Physical and Materials Sciences, Computational Biology, Machine Learning
Topic: Cerebrospinal fluid and hydrocephalus (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: NIH (R01AT012312, U19NS128613); Army Research Office (W911NF1910280); Air Force Office of Scientific Research (FA9550-20-1-0358); ONR (N00014-22-1-2795)
Citations: cited by 2 papers (Europe PMC); 85 references in the paper

Abstract

The circulation of cerebrospinal and interstitial fluid plays a vital role in clearing metabolic waste from the brain, and its disruption has been linked to neurological disorders. However, directly measuring brain-wide fluid transport, especially in the deep brain, has remained elusive. Here, we introduce magnetic resonance artificial intelligence velocimetry (MR-AIV), a framework featuring a specialized physics-informed architecture and optimization method that reconstructs three-dimensional fluid velocity fields from dynamic contrast-enhanced magnetic resonance imaging (DCE-MRI). MR-AIV unveils brain-wide velocity maps while providing estimates of tissue permeability and pressure fields, quantities inaccessible to other methods. Applied to the brain, MR-AIV reveals a functional landscape of interstitial and perivascular flow, quantitatively distinguishing slow diffusion-driven transport [∼0.1 micrometers per second (μm/s)] from rapid advective flow (∼3 μm/s). This approach enables new investigations into brain clearance mechanisms and fluid dynamics in health and disease, with broad potential applications to other porous medium systems, from geophysics to tissue mechanics.

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

Repository

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

jdtoscano94/MR-AIV

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: f242e08e8c4f1fb82f395e363b258d4259600cba, 31 May 2026
Languages: Python (12), Jupyter (2)
Size: 60 files, 14 scripts
Software Heritage: not archived
Found in: “Data, code, and materials availability:”
Holds: README, environment (pyproject.toml, setup.cfg), 2 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (11 files), JAX (10 files), h5py (9 files), Matplotlib (9 files), SciPy (9 files), pandas (7 files), scikit-learn (7 files), OpenCV (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
15 files
At the source: github.com/jdtoscano94/MR-AIV

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 14 scripts, each with its path and the digest of its content;
  • 1 match between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data, code, and materials availability

All data and code needed to evaluate and reproduce the results in the paper are present in the paper and/or the Supplementary Materials. The full dataset used in this study (including original DCE-MRI data, synthetic validation data, and preprocessed training data), along with the complete MR-AIV codebase, is publicly archived on Zenodo at https://zenodo.org/records/15345392. Additionally, to ease accessibility and provide detailed usage instructions, the codebase has also been made available via a public GitHub repository at https://github.com/jdtoscano94/MR-AIV. This study did not generate new materials.

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

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 6 MeSH terms, 4 funders, 69 references.

Cite

This paper

Toscano, J. D., Guo, Y., Wang, Z., Vaezi, M., Mori, Y., Karniadakis, G. E., Boster, K. A. S., & Kelley, D. H. (2026). MR-AIV reveals in vivo brain-wide fluid flow with physics-informed AI. Science advances, 12(22), eaeb0404. https://doi.org/10.1126/sciadv.aeb0404

BibTeX

@article{toscano2026mr,
author = {Toscano, Juan Diego and Guo, Yisen and Wang, Zhibo and Vaezi, Mohammad and Mori, Yuki and Karniadakis, George Em and Boster, Kimberly A. S. and Kelley, Douglas H.},
title = {{MR-AIV reveals in vivo brain-wide fluid flow with physics-informed AI}},
journal = {Science advances},
year = {2026},
month = may,
volume = {12},
number = {22},
pages = {eaeb0404},
publisher = {American Association for the Advancement of Science},
issn = {2375-2548},
doi = {10.1126/sciadv.aeb0404},
url = {https://doi.org/10.1126/sciadv.aeb0404},
pmid = {42202031},
pmcid = {PMC13215179}
}

RIS

TY - JOUR
AU - Toscano, Juan Diego
AU - Guo, Yisen
AU - Wang, Zhibo
AU - Vaezi, Mohammad
AU - Mori, Yuki
AU - Karniadakis, George Em
AU - Boster, Kimberly A. S.
AU - Kelley, Douglas H.
TI - MR-AIV reveals in vivo brain-wide fluid flow with physics-informed AI
T2 - Science advances
J2 - Sci Adv
PY - 2026
DA - 2026/05/27
VL - 12
IS - 22
SP - eaeb0404
SN - 2375-2548
PB - American Association for the Advancement of Science
DO - 10.1126/sciadv.aeb0404
UR - https://doi.org/10.1126/sciadv.aeb0404
LA - en
ER -

CSL-JSON

{
"id": "10.1126/sciadv.aeb0404",
"type": "article-journal",
"title": "MR-AIV reveals in vivo brain-wide fluid flow with physics-informed AI",
"container-title": "Science advances",
"author": [
{
"family": "Toscano",
"given": "Juan Diego"
},
{
"family": "Guo",
"given": "Yisen"
},
{
"family": "Wang",
"given": "Zhibo"
},
{
"family": "Vaezi",
"given": "Mohammad"
},
{
"family": "Mori",
"given": "Yuki"
},
{
"family": "Karniadakis",
"given": "George Em"
},
{
"family": "Boster",
"given": "Kimberly A. S."
},
{
"family": "Kelley",
"given": "Douglas H."
}
],
"container-title-short": "Sci Adv",
"volume": "12",
"issue": "22",
"page": "eaeb0404",
"DOI": "10.1126/sciadv.aeb0404",
"PMID": "42202031",
"PMCID": "PMC13215179",
"ISSN": "2375-2548",
"publisher": "American Association for the Advancement of Science",
"URL": "https://doi.org/10.1126/sciadv.aeb0404",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
27
]
]
}
}

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.1186/s12987-026-00782-w
Quantifying cerebrospinal fluid flow in pial perivascular spaces of rats.
Journal: Fluids and barriers of the CNS
In common: 11 references, author Douglas H. Kelley
[2] doi:10.1073/pnas.2526239123 [code]
Quantitative assessment of flow between cerebrospinal and interstitial fluid compartments in humans.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: structural MRI / diffusion, 8 references
[3] doi:10.1038/s41467-026-76306-9 [code]
Non-invasive characterization of perivascular subarachnoid spaces.
Journal: Nature communications
In common: scikit-learn, SciPy, Matplotlib, 1 other tool, structural MRI / diffusion, 5 references
[4] doi:10.1073/pnas.2517059123 [code]
Stretch and flow at the gliovascular interface: High-fidelity modeling of astrocyte endfeet.
Journal: Proceedings of the National Academy of Sciences of the United States of America
In common: pandas, SciPy, Matplotlib, 1 other tool, 5 references
[5] doi:10.1002/hipo.70131 [code]
Decoding Medial Entorhinal Cortical Dynamics Produces Planning-Like Alternations in Hippocampal theta Sequences.
Journal: Hippocampus
In common: JAX, OpenCV, h5py, 5 other tools, systems
[6] 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: JAX, OpenCV, h5py, 5 other tools, systems
[7] doi:10.1093/brain/awag080 [code]
Early glymphatic failure in AppNL-F knock-in mice is linked to parenchymal border macrophages loss.
Journal: Brain : a journal of neurology
In common: 6 references
[8] doi:10.1002/mrm.70514 [code]
Brain Clearance of Contrast Agent in Intravenous DCE-MRI Is Measurable and Cannot Be Explained by Clearance Across the BBB Alone.
Journal: Magnetic resonance in medicine
In common: pandas, SciPy, Matplotlib, 1 other tool, structural MRI / diffusion, 4 references
[9] doi:10.1177/0271678x261455452 [code]
Meningeal CSF transport varies across parasagittal dura subregions with age in humans.
Journal: Journal of cerebral blood flow and metabolism : official journal of the International Society of Cerebral Blood Flow and Metabolism
In common: structural MRI / diffusion, 5 references
[10] doi:10.1002/alz.71745 [code]
Regional astrocyte dysregulation and altered glymphatic-related markers in Alzheimer's disease frontal cortex.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: OpenCV, pandas, SciPy, 2 other tools, 3 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.