OSCR

ProtoCloud: A prototypical self-explaining model for single-cell analysis.

Code ↔ Paper

21 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 21 matches
  1. [1] § STAR★Methods › Method details › Reliability and uncertainty estimation ↔ src/ProtoCloud/model/calibrator.py, lines 10–26 · score 0.72 · global isotonic regression, global calibration, calibrated probability, fit, mapping, scores
  2. [2] § Design ↔ src/ProtoCloud/model/model.py, lines 68–101 · score 0.72 · deep generative model, latent space organized, low dimensional, embeds, ProtoCloud, encoder
  3. [3] § STAR★Methods › Method details › The ProtoCloud model ↔ src/ProtoCloud/model/model.py, lines 68–101 · score 0.70 · low dimensional, generative model, prototype vector, latent space, embeds, bias
  4. [4] § Design ↔ src/ProtoCloud/model/model.py, lines 272–340 · score 0.69 · cross entropy, orthogonal loss, atomic loss, multinomial, components, identity
  5. [5] § STAR★Methods › Method details › Ablation study › Two-stage vs. single-stage curriculum ↔ src/ProtoCloud/model/train.py, lines 19–84 · score 0.68 · stage curriculum, orthogonal loss, atomic loss, stage training, ProtoCloud, model
  6. [6] § STAR★Methods › Method details › Evaluation metrics ↔ src/ProtoCloud/model/calibrator.py, lines 209–236 · score 0.68 · expected calibration error, predicted probability, conf, bins, ECE, accuracy
  7. [7] § Design ↔ src/ProtoCloud/prp/lrp.py, lines 295–377 · score 0.67 · prototypical relevance propagation, gene relevance, relevance score, backpropagating, gene expression, explanatory
  8. [8] § STAR★Methods › Method details › Shaping latent spaces through a two-stage curriculum and latent decomposition ↔ src/ProtoCloud/model/model.py, lines 486–512 · score 0.65 · L1 regularization, layer weight, sparsity, encourages, matrix, encoder
  9. [9] § Results › Batch-separated informative latent space ↔ src/ProtoCloud/model/train.py, lines 19–84 · score 0.64 · orthogonal loss, stage curriculum, atomic loss, stage training, ProtoCloud, batch
  10. [10] § STAR★Methods › Method details › Prototypical relevance propagation for gene-level interpretation ↔ src/ProtoCloud/model/model.py, lines 21–47 · score 0.63 · fully connected layer, ReLU, activation, linear
  11. [11] § STAR★Methods › Method details › Model architecture and training ↔ main.py, lines 371–438 · score 0.63 · AdamW, batch normalization, optimizer, ReLU, activation, bias
  12. [12] § Results › Batch-separated informative latent space ↔ src/ProtoCloud/model/model.py, lines 272–340 · score 0.61 · loss component, orthogonal loss, atomic loss, entropy, batch, latent
  13. [13] § STAR★Methods › Method details › The ProtoCloud model ↔ src/ProtoCloud/model/model.py, lines 386–429 · score 0.59 · negative binomial, dispersion parameter, likelihood, reconstructing, NB, latent
  14. [14] § STAR★Methods › Method details › Data collection and processing › Patch-seq RGC ↔ src/ProtoCloud/data/scRNAdata.py, lines 33–91 · score 0.58 · single cell RNA, model trained, Seq, raw, genes
  15. [15] § Results › Similarity-guided annotation correction with justification ↔ src/ProtoCloud/model/calibrator.py, lines 157–206 · score 0.56 · expected calibration error, Brier score, ECE, metrics, prediction, model
  16. [16] § Results › Similarity-guided annotation correction with justification ↔ src/ProtoCloud/model/calibrator.py, lines 99–131 · score 0.55 · expected calibration error, Brier score, ECE, prediction, model
  17. [17] § STAR★Methods › Method details › The orthogonal loss to help learn diverse prototypes for each class ↔ src/ProtoCloud/model/model.py, lines 179–213 · score 0.53 · cross entropy, orthogonal loss, class, prototype, model
  18. [18] § STAR★Methods › Method details › Evaluation metrics ↔ src/ProtoCloud/utils/utils.py, lines 461–484 · score 0.51 · nearest neighbors, batch entropy
  19. [19] § STAR★Methods › Method details › Evaluation metrics ↔ src/ProtoCloud/utils/utils.py, lines 441–464 · score 0.51 · nearest neighbors, batch entropy
  20. [20] § Results › Similarity-guided annotation correction with justification › Type 2: Ambiguous misprediction ↔ src/ProtoCloud/model/calibrator.py, lines 157–206 · score 0.51 · Brier score, calibrated score, ECE, metrics, probability
  21. [21] § STAR★Methods › Method details › Prototypical relevance propagation for gene-level interpretation ↔ src/ProtoCloud/prp/lrp.py, lines 295–377 · score 0.51 · prototypical relevance propagation, backpropagated, LRP, PRP, dimensional, protoCloud

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 · 867 lines · 32 KB · MIT · 6 matches

  1. from typing import Any, Iterable, Mapping, Sequence, Tuple, Union, Optional, Callable, Literal, List
  2. import torch
  3. import torch.nn as nn
  4. import torch.nn.functional as F
  5. from torch.distributions import Distribution, Gamma, Poisson
  6. import numpy as np
  7. import pandas as pd
  9. import ProtoCloud.glo as glo
  10. glo.set_value('EPS', 1e-16)
  11. glo.set_value('LRP_FILTER_TOP_K', 0.1)
  13. from ..utils import seed_torch, log_likelihood_nb, one_hot_encoder
  15. device = 'cuda' if torch.cuda.is_available() else 'cpu'
  16. num_workers = 4 if torch.cuda.is_available() else 0
  18. EPS = glo.get_value('EPS')
  21. def form_block(in_dim, out_dim,
  22. use_bn = True, activation = 'relu',
  23. bias = False, dropout = 0,
  24. ):
  25. """Construct a sequential block of Linear, BatchNorm, activation, and dropout.
  27. Parameters
  28. ----------
  29. in_dim : int
  30. Input feature dimension.
  31. out_dim : int
  32. Output feature dimension.
  33. use_bn : bool, optional
  34. Whether to include BatchNorm1d, by default True.
  35. activation : {'relu', 'leakyrelu'}, optional
  36. Activation function type, by default 'relu'.
  37. bias : bool, optional
  38. Whether to add bias to the Linear layer, by default False.
  39. dropout : float, optional
  40. Dropout rate. Set to 0 to disable, by default 0.
  42. Returns
  43. -------
  44. torch.nn.Sequential
  45. The composed layer block.
  47. Raises
  48. ------
  49. ValueError
  50. If ``activation`` is not recognized.
  51. """
  52. layers = [nn.Linear(in_dim, out_dim, bias=bias)]
  53. if use_bn:
  54. layers.append(nn.BatchNorm1d(out_dim))
  55. # activation
  56. if activation == 'relu':
  57. layers.append(nn.ReLU())
  58. elif activation == 'leakyrelu':
  59. layers.append(nn.LeakyReLU())
  60. else:
  61. raise ValueError('activation not recognized')
  62. if dropout != 0:
  63. layers.append(nn.Dropout(dropout))
  65. return nn.Sequential(*layers)
  68. class protoCloud(nn.Module):
  69. """
  70. ProtoCloud, a self-explaining deep generative model trained end-to-end to embed cells into a structured, low-dimensional space organized around cell type-specific prototypes.
  72. Parameters
  73. ----------
  74. input_dim : int
  75. Number of input genes.
  76. num_prototypes_per_class : int
  77. Number of prototype vectors per cell type.
  78. num_classes : int
  79. Number of cell types.
  80. latent_dim : int
  81. Dimensionality of the latent space.
  82. raw_input : int
  83. 1 if input is raw counts (applies log1p), 0 if log-normalized.
  84. encoder_layer_sizes : list of int, optional
  85. Hidden layer sizes for the encoder, by default [1024, 512, 256].
  86. decoder_layer_sizes : list of int, optional
  87. Hidden layer sizes for the decoder, by default [512, 1024].
  88. activation : {'relu', 'leakyrelu'}, optional
  89. Activation function, by default 'relu'.
  90. use_bias : bool, optional
  91. Whether to use bias in Linear layers, by default False.
  92. use_dropout : float, optional
  93. Dropout rate, by default 0.
  94. use_bn : bool, optional
  95. Whether to use batch normalization, by default True.
  96. obs_dist : {'nb', 'normal'}, optional
  97. Observation distribution for reconstruction, by default 'nb'.
  98. nb_dispersion : {'celltype_target', 'celltype_pred', 'gene'}, optional
  99. How to model negative binomial dispersion, by default
  100. 'celltype_target'.
  101. """
  103. def __init__(self, input_dim:int,
  104. num_classes:int,
  105. num_prototypes_per_class: int = 6,
  106. latent_dim: int = 20,
  107. raw_input:int = 1,
  108. encoder_layer_sizes: Optional[list] = None,
  109. decoder_layer_sizes: Optional[list] = None,
  110. activation: Literal['relu', 'leakyrelu'] = 'relu',
  111. use_bias:bool = False,
  112. use_dropout:float = 0,
  113. use_bn:bool = True,
  114. obs_dist: Literal['nb', 'normal'] = 'nb',
  115. nb_dispersion: Literal['celltype_target', 'celltype_pred', 'gene'] = "celltype_target",
  116. # n_batch:int = 1,
  117. ):
  118. super(protoCloud, self).__init__()
  119. self.input_dim = input_dim
  120. self.latent_dim = latent_dim
  121. self.num_prototypes_per_class = num_prototypes_per_class
  122. self.num_classes = num_classes
  123. self.raw_input = raw_input
  124. self.activation = activation
  125. self.use_bn = use_bn
  126. self.use_bias = bool(use_bias)
  127. self.use_dropout = use_dropout
  128. self.obs_dist = None if not self.raw_input else obs_dist
  129. self.nb_dispersion = nb_dispersion
  130. self.epsilon = EPS
  131. # self.n_batch = n_batch
  133. # prototype-class labeled matrix
  134. self.num_prototypes = self.num_prototypes_per_class * self.num_classes
  135. identity = torch.zeros(self.num_prototypes, self.num_classes)
  136. for j in range(self.num_prototypes):
  137. identity[j, j // self.num_prototypes_per_class] = 1
  138. self.register_buffer('prototype_class_identity', identity) # register buffer to move to GPU automatically
  140. # prototype vectors
  141. prototype_shape = (self.num_prototypes, self.latent_dim)
  142. self.prototype_vectors = nn.Parameter(torch.randn(prototype_shape), requires_grad = True)
  143. # mask
  144. self.scale = nn.Parameter(torch.ones(1) * 1.0)
  147. #######################################################
  148. if encoder_layer_sizes is None:
  149. self.encoder_layer_sizes = [self.input_dim] + [1024, 512, 256] # [128, 64, 32]
  150. else:
  151. self.encoder_layer_sizes = [self.input_dim] + encoder_layer_sizes
  152. if decoder_layer_sizes is None:
  153. # self.latent_dim += self.n_batch
  154. self.decoder_layer_sizes = [self.latent_dim] + [512, 1024] # [32, 128]
  155. else:
  156. self.decoder_layer_sizes = [self.latent_dim] + decoder_layer_sizes
  157. # self.decoder_layer_sizes[0] += self.n_batch
  159. # Encoder
  160. self.encoder = nn.Sequential()
  161. for i, (in_dim, out_dim) in enumerate(zip(self.encoder_layer_sizes[:-1], self.encoder_layer_sizes[1:])):
  162. self.encoder.add_module(str(i), form_block(in_dim, out_dim,
  163. self.use_bn, self.activation, self.use_bias, self.use_dropout))
  165. self.z_mean = nn.Linear(self.encoder_layer_sizes[-1], latent_dim, bias = True)
  166. self.z_log_var = nn.Linear(self.encoder_layer_sizes[-1], latent_dim, bias = True)
  168. # Decoder
  169. self.decoder = nn.Sequential()
  170. for i, (in_dim, out_dim) in enumerate(zip(self.decoder_layer_sizes[:-1], self.decoder_layer_sizes[1:])):
  171. self.decoder.add_module(str(i), form_block(in_dim, out_dim,
  172. self.use_bn, self.activation, self.use_bias, self.use_dropout))
  173. self.px_mean = nn.Linear(self.decoder_layer_sizes[-1], input_dim, bias = True)
  175. # likelihood
  176. self.softmax = nn.Softmax(dim = -1)
  177. # nb dispersion: gene-specific
  178. self.px_theta = nn.Sequential(
  179. nn.Linear(self.decoder_layer_sizes[-1], input_dim, bias = True),
  180. nn.Softplus()) # output always positive
  181. # nb dispersion: celltype-specific
  182. self.theta = nn.Parameter(torch.randn(self.input_dim, self.num_classes))
  184. # Classifier
  185. self.classifier = nn.Linear(self.num_prototypes, self.num_classes, bias = False)
  186. self._initialize_weights()
  190. def forward(self, x, batch_id=None):
  191. """Forward pass through the full model.
  193. Parameters
  194. ----------
  195. x : torch.Tensor
  196. Input gene expression of shape ``(batch_size, input_dim)``.
  197. batch_id : optional
  198. Batch information (currently unused).
  200. Returns
  201. -------
  202. pred : torch.Tensor
  203. Classification logits, shape ``(batch_size, num_classes)``.
  204. px_mu : torch.Tensor
  205. Reconstruction mean, shape ``(batch_size, input_dim)``.
  206. px_t : torch.Tensor or None
  207. Dispersion parameters for NB distribution, or None.
  208. z_mu : torch.Tensor
  209. Latent mean, shape ``(batch_size, latent_dim)``.
  210. z_logVar : torch.Tensor
  211. Latent log-variance, shape ``(batch_size, latent_dim)``.
  212. sim_scores : torch.Tensor
  213. Prototype similarity scores, shape ``(batch_size, num_prototypes)``.
  214. """
  215. self.lib_size = torch.sum(x, 1, True)
  217. if self.raw_input: # raw: 1
  218. x = torch.log1p(x)
  220. encode = self.encoder(x)
  221. z_mu = self.z_mean(encode)
  222. z_logVar = self.z_log_var(encode)
  223. z = self.reparameterize(z_mu, z_logVar)
  225. sim_scores = self.calc_sim_scores(z)
  226. pred = self.classifier(sim_scores)
  228. px = self.decoder(z)
  229. px_mu = self.px_mean(px)
  231. if self.obs_dist == 'nb':
  232. px_mu = self.softmax(px_mu) * self.lib_size
  233. if self.nb_dispersion.startswith('celltype') :
  234. px_t = self.theta
  235. elif self.nb_dispersion == 'gene':
  236. px_t = self.px_theta(px)
  237. px_t = torch.mean(px_t, 0, True)
  238. else:
  239. raise NotImplementedError
  241. px_t = torch.clamp(px_t, min = EPS)
  242. else:
  243. px_t = None
  245. return pred, px_mu, px_t, z_mu, z_logVar, sim_scores
  248. def reparameterize(self, mu, logvar):
  249. """Sample from the latent distribution using the reparameterization trick.
  251. Computes ``z = mu + exp(logvar / 2) * epsilon`` where epsilon is
  252. sampled from a standard normal.
  254. Parameters
  255. ----------
  256. mu : torch.Tensor
  257. Mean of the latent distribution.
  258. logvar : torch.Tensor
  259. Log-variance of the latent distribution.
  261. Returns
  262. -------
  263. torch.Tensor
  264. Sampled latent vector, same shape as ``mu``.
  265. """
  266. std = torch.exp(logvar / 2)
  267. eps = torch.randn_like(std)
  269. return mu + std * eps
  272. def loss_function(self, x, target, pred,
  273. px_mu, px_theta,
  274. z_mu, z_logVar,
  275. sim_scores):
  276. """Compute all loss components for training.
  278. Parameters
  279. ----------
  280. x : torch.Tensor
  281. Input gene expression, shape ``(batch_size, input_dim)``.
  282. target : torch.Tensor
  283. Ground truth class labels, shape ``(batch_size,)``.
  284. pred : torch.Tensor
  285. Classification logits from the forward pass.
  286. px_mu : torch.Tensor
  287. Reconstruction mean from the forward pass.
  288. px_theta : torch.Tensor
  289. Dispersion parameters from the forward pass.
  290. z_mu : torch.Tensor
  291. Latent mean from the forward pass.
  292. z_logVar : torch.Tensor
  293. Latent log-variance from the forward pass.
  294. sim_scores : torch.Tensor
  295. Prototype similarity scores from the forward pass.
  297. Returns
  298. -------
  299. recon_loss : torch.Tensor
  300. Reconstruction loss (NB log-likelihood or MSE).
  301. kl_loss : torch.Tensor
  302. KL divergence to class prototypes.
  303. classify_loss : torch.Tensor
  304. Cross-entropy classification loss.
  305. ortho_loss : torch.Tensor
  306. Orthogonality loss for prototype separation.
  307. atomic_loss : torch.Tensor
  308. Attraction/repulsion loss for prototype assignment.
  309. """
  310. if target.max() >= self.prototype_class_identity.shape[0]:
  311. print("Max target:", target.max())
  312. print("Shape of prototype_class_identity:", self.prototype_class_identity.shape)
  313. raise IndexError("Target index is out of bounds.")
  315. # Reconstruction loss
  316. if self.nb_dispersion == 'celltype_target' or self.nb_dispersion == 'gene':
  317. recon_loss, _ = self.recon_loss(x, target, px_mu, px_theta)
  318. else: # self.nb_dispersion == 'celltype_pred'
  319. softmax_pred = F.softmax(pred, dim=1)
  320. max_index = torch.multinomial(softmax_pred, 1)
  321. recon_loss, _ = self.recon_loss(x, max_index, px_mu, px_theta)
  323. prototypes_of_correct_class = self.prototype_class_identity[:, target].t()
  324. index_prototypes_of_correct_class = (prototypes_of_correct_class == 1).nonzero(as_tuple = True)[1]
  325. # class-corresponding prototypes' index for each sample in the batch
  326. index_prototypes_of_correct_class = index_prototypes_of_correct_class.view(x.shape[0],
  327. self.num_prototypes_per_class)
  328. # KL divergence loss
  329. kl_loss, mask = self.kl_divergence_nearest(z_mu, z_logVar, index_prototypes_of_correct_class, sim_scores)
  331. # Classification loss
  332. classify_loss = F.cross_entropy(pred, target)
  334. # Orthogonality loss
  335. ortho_loss = self.orthogonal_loss()
  337. # Atomic loss
  338. atomic_loss = self.atomic_loss(sim_scores, prototypes_of_correct_class)
  340. return recon_loss, kl_loss, classify_loss, ortho_loss, atomic_loss
  343. def calc_sim_scores(self, z):
  344. """Compute similarity scores between latent embeddings and prototypes.
  346. Uses the first half of latent dimensions to compute pairwise
  347. Euclidean distances, then converts to similarities via the
  348. Cauchy kernel.
  350. Parameters
  351. ----------
  352. z : torch.Tensor
  353. Latent embeddings, shape ``(batch_size, latent_dim)``.
  355. Returns
  356. -------
  357. torch.Tensor
  358. Similarity scores, shape ``(batch_size, num_prototypes)``.
  359. """
  360. # pairwise Euclidean distances between z and prototype vectors
  361. d = torch.cdist(z[:, :self.latent_dim // 2],
  362. self.prototype_vectors[:, :self.latent_dim // 2], p = 2) ## Batch size x num_prototypes
  363. sim_scores = self.distance_2_similarity(d)
  364. return sim_scores
  367. def distance_2_similarity(self, distances):
  368. """Convert distances to similarities using a Cauchy kernel.
  370. Computes ``1 / (scale^2 * d^2 + 1)``, yielding values in [0, 1].
  372. Parameters
  373. ----------
  374. distances : torch.Tensor
  375. Pairwise distance values.
  377. Returns
  378. -------
  379. torch.Tensor
  380. Similarity scores in [0, 1], same shape as input.
  381. """
  382. # return torch.log((distances + 1) / (distances + self.epsilon))
  383. return 1.0 / (torch.square(distances * self.scale) + 1.0) # heavy tail
  386. def recon_loss(self, x, target, px_mu, px_t):
  387. """Compute reconstruction loss.
  389. Uses negative binomial log-likelihood for count data or MSE
  390. for normalized data.
  392. Parameters
  393. ----------
  394. x : torch.Tensor
  395. Ground truth expression, shape ``(batch_size, input_dim)``.
  396. target : torch.Tensor
  397. Class labels, used for cell-type-specific dispersion.
  398. px_mu : torch.Tensor
  399. Predicted reconstruction mean.
  400. px_t : torch.Tensor or None
  401. Dispersion parameters.
  403. Returns
  404. -------
  405. loss : torch.Tensor
  406. Scalar reconstruction loss.
  407. dispersion : torch.Tensor or None
  408. Computed dispersion values, or None for normal distribution.
  409. """
  410. if self.obs_dist == 'nb':
  411. if self.nb_dispersion.startswith('celltype'):
  412. dispersion = F.linear(one_hot_encoder(target, self.num_classes), self.theta)
  413. dispersion = torch.exp(dispersion)
  415. elif self.nb_dispersion == 'gene':
  416. dispersion = px_t
  417. else:
  418. raise NotImplementedError
  420. ll = -log_likelihood_nb(x, px_mu, dispersion)
  421. recon_loss = torch.mean(torch.sum(ll, dim = -1))
  422. recon_loss = recon_loss / self.input_dim * self.latent_dim / 2.0 # scale nb loss down
  424. else:
  425. # x = F.normalize(x, dim = 0)
  426. recon_loss = torch.nn.functional.mse_loss(px_mu, x, reduction = "mean")
  427. dispersion = None
  429. return recon_loss, dispersion
  432. def kl_divergence_nearest(self, mu, logVar, nearest_pt, sim_scores):
  433. """Compute KL divergence to nearest class prototypes.
  435. The first half of the latent space is regularized toward prototype
  436. distributions (weight 5); the second half toward a standard
  437. normal (weight 1). Losses are weighted by similarity scores.
  439. Parameters
  440. ----------
  441. mu : torch.Tensor
  442. Latent means, shape ``(batch_size, latent_dim)``.
  443. logVar : torch.Tensor
  444. Latent log-variances, shape ``(batch_size, latent_dim)``.
  445. nearest_pt : torch.Tensor
  446. Prototype indices for correct class, shape
  447. ``(batch_size, num_prototypes_per_class)``.
  448. sim_scores : torch.Tensor
  449. Similarity scores, shape ``(batch_size, num_prototypes)``.
  451. Returns
  452. -------
  453. kl_loss : torch.Tensor
  454. Scalar KL divergence loss.
  455. mask : torch.Tensor
  456. Boolean mask indicating contributing prototypes.
  457. """
  458. kl_loss = torch.zeros(sim_scores.shape).to(device)
  459. half_latent = self.latent_dim // 2
  461. for i in range(self.num_prototypes_per_class):
  462. p_v = self.prototype_vectors[nearest_pt[:, i], :] # all class prototype i vector
  464. kl1 = torch.distributions.kl.kl_divergence(
  465. torch.distributions.Normal(mu[:, :half_latent], torch.exp(logVar[:, :half_latent] / 2)),
  466. torch.distributions.Normal(p_v[:, :half_latent], torch.ones(p_v[:, :half_latent].shape).to(device))
  467. )
  469. kl2 = torch.distributions.kl.kl_divergence(
  470. torch.distributions.Normal(mu[:, half_latent:], torch.exp(logVar[:, half_latent:] / 2)),
  471. # torch.distributions.Normal(torch.zeros_like(p_v[:, half_latent:]).to(device), torch.ones_like(p_v[:, half_latent:]).to(device))
  472. torch.distributions.Normal(torch.zeros_like(p_v[:, half_latent:]), torch.ones_like(p_v[:, half_latent:]).to(device))
  473. )
  475. kl = torch.mean(kl1 * 5 + kl2, dim=-1)
  476. kl_loss[np.arange(sim_scores.shape[0]), nearest_pt[:, i]] = kl
  478. kl_loss = kl_loss * sim_scores # element-wise scale by similarity scores
  479. mask = kl_loss > 0 # prototypes contributes
  480. kl_loss = torch.sum(kl_loss, dim = -1) / (torch.sum(sim_scores * mask, dim = -1))
  481. kl_loss = torch.mean(kl_loss)
  483. return kl_loss, mask
  486. def orthogonal_loss(self):
  487. """Compute orthogonality loss for prototype diversity.
  489. Encourages prototypes within the same class to be orthogonal
  490. in the first half of the latent space. Also includes L1
  491. sparsity regularization on the first encoder layer weights.
  493. Returns
  494. -------
  495. torch.Tensor
  496. Scalar orthogonality + sparsity loss.
  497. """
  498. s_loss = 0
  499. for k in range(self.num_classes):
  500. # p_k = self.prototype_vectors[k*self.num_prototypes_per_class : (k+1)*self.num_prototypes_per_class, :]
  501. p_k = self.prototype_vectors[k*self.num_prototypes_per_class : (k+1)*self.num_prototypes_per_class, :self.latent_dim//2]
  503. p_k_mean = torch.mean(p_k, dim = 0)
  504. p_k_2 = p_k - p_k_mean
  505. p_k_dot = p_k_2 @ p_k_2.T
  506. s_matrix = p_k_dot - (torch.eye(p_k.shape[0]).to(device))
  507. s_loss += torch.norm(s_matrix, p = 2)
  509. # # L1 regularization
  510. sparsity = 1.0 / torch.numel(self.encoder[0][0].weight) * torch.norm(self.encoder[0][0].weight, 1)
  512. return s_loss / self.num_classes + sparsity
  515. def atomic_loss(self, sim_scores, mask):
  516. """Compute attraction/repulsion loss for prototype assignment.
  518. Encourages high similarity to correct-class prototypes
  519. (attraction) and low similarity to incorrect-class prototypes
  520. (repulsion).
  522. Parameters
  523. ----------
  524. sim_scores : torch.Tensor
  525. Prototype similarities, shape ``(batch_size, num_prototypes)``.
  526. mask : torch.Tensor
  527. Boolean mask for correct-class prototypes.
  529. Returns
  530. -------
  531. torch.Tensor
  532. Scalar loss (repulsion - attraction).
  533. """
  534. attraction = torch.mean(torch.max(sim_scores * mask, 1).values)
  535. repulsion = torch.mean(torch.max(sim_scores * torch.logical_not(mask), 1).values)
  536. # repulsion = torch.sum(torch.mean(sim_scores * torch.logical_not(mask), 1).values)
  537. return repulsion - attraction
  541. def set_last_layer_incorrect_connection(self, incorrect_strength):
  542. """Initialize classifier weights based on prototype-class identity.
  544. Sets weights to 1 for correct class connections and
  545. ``incorrect_strength`` for incorrect class connections.
  547. Parameters
  548. ----------
  549. incorrect_strength : float
  550. Weight for incorrect class connections (e.g., -0.5).
  551. """
  552. positive_one_weights_locations = torch.t(self.prototype_class_identity)
  553. negative_one_weights_locations = 1 - positive_one_weights_locations
  555. correct_class_connection = 1
  556. incorrect_class_connection = incorrect_strength
  557. self.classifier.weight.data.copy_(
  558. correct_class_connection * positive_one_weights_locations
  559. + incorrect_class_connection * negative_one_weights_locations)
  563. def _initialize_weights(self):
  564. '''
  565. initialize weights for vae
  566. '''
  567. for m in self.encoder.modules():
  568. if isinstance(m, nn.Linear):
  569. nn.init.uniform_(m.weight, -0.08, 0.08)
  570. if m.bias is not None:
  571. nn.init.constant_(m.bias, 0)
  573. elif isinstance(m, nn.BatchNorm1d):
  574. nn.init.constant_(m.weight, 1)
  575. nn.init.constant_(m.bias, 0.001)
  577. for m in self.decoder.modules():
  578. if isinstance(m, nn.Linear):
  579. nn.init.uniform_(m.weight, -0.08, 0.08)
  580. if m.bias is not None:
  581. nn.init.constant_(m.bias, 0)
  583. elif isinstance(m, nn.BatchNorm1d):
  584. nn.init.constant_(m.weight, 1)
  585. nn.init.constant_(m.bias, 0.001)
  587. self.set_last_layer_incorrect_connection(incorrect_strength = -0.5)
  591. # get results helper functions
  592. #######################################################
  593. @property
  594. def get_prototypes(self):
  595. """torch.Tensor : Prototype vectors of shape ``(num_prototypes, latent_dim)``."""
  596. return self.prototype_vectors
  598. def get_prototype_cells(self):
  599. """Decode prototype vectors to gene expression space.
  601. Samples 100 times from the reconstruction distribution for each
  602. prototype and returns the mean counts.
  604. Returns
  605. -------
  606. torch.Tensor
  607. Prototype cells in gene space, shape
  608. ``(num_prototypes, input_dim)``.
  609. """
  610. px_mu, px_theta = self.get_latent_decode(self.prototype_vectors)
  611. # sample 100 and take avg for each
  612. proto_cells = torch.zeros(self.num_prototypes, self.input_dim)
  613. for i in range(self.num_classes):
  614. x_mu = px_mu[i*self.num_prototypes_per_class : (i+1)*self.num_prototypes_per_class, :]
  615. for j in range(self.num_prototypes_per_class):
  616. t = px_theta[:,i]
  617. mu = x_mu[j]
  618. proto_cells[i*self.num_prototypes_per_class + j, :] = torch.mean(self.sample_recon(mu, t, 100), axis=0)
  619. return proto_cells
  622. def max_sim_score(self, sim_scores):
  623. """Find the maximum similarity score per class and the best-matching prototype.
  625. Parameters
  626. ----------
  627. sim_scores : torch.Tensor
  628. Similarity scores, shape ``(batch_size, num_prototypes)``.
  630. Returns
  631. -------
  632. max_sim : torch.Tensor
  633. Maximum similarity to nearest prototype, shape ``(batch_size,)``.
  634. nearest_proto_idx : torch.Tensor
  635. Index of the nearest prototype within its class, shape ``(batch_size,)``.
  636. """
  637. sim_reshaped = sim_scores.view(-1, self.num_classes, self.num_prototypes_per_class)
  639. # max sim to a prototype for each class
  640. max_sim_per_cls, max_proto_indices_per_class = torch.max(sim_reshaped, dim=2)
  641. # Find the nearest class for each cell
  642. max_sim, nearest_cls_idx = torch.max(max_sim_per_cls, dim=1)
  643. # The indices of the nearest prototypes
  644. nearest_proto_idx = max_proto_indices_per_class[range(sim_reshaped.shape[0]), nearest_cls_idx]
  646. return max_sim, nearest_proto_idx
  649. def get_pred(self, x, test=False):
  650. """Get classification predictions.
  652. Parameters
  653. ----------
  654. x : torch.Tensor
  655. Input gene expression, shape ``(batch_size, input_dim)``.
  656. test : bool, optional
  657. If True, use latent mean only (deterministic); otherwise
  658. sample via reparameterization, by default False.
  660. Returns
  661. -------
  662. pred : torch.Tensor
  663. Classification logits, shape ``(batch_size, num_classes)``.
  664. max_sim : torch.Tensor
  665. Maximum similarity to nearest prototype.
  666. proto_idx : torch.Tensor
  667. Index of the nearest prototype.
  668. """
  669. self.eval()
  670. if self.raw_input: # raw: 1
  671. x = torch.log1p(x)
  673. encode = self.encoder(x)
  674. z_mu = self.z_mean(encode)
  675. if test:
  676. z = z_mu
  677. else:
  678. z_logVar = self.z_log_var(encode)
  679. z = self.reparameterize(z_mu, z_logVar)
  681. sim_scores = self.calc_sim_scores(z)
  682. pred = self.classifier(sim_scores)
  683. max_sim, proto_idx = self.max_sim_score(sim_scores)
  685. return pred, max_sim, proto_idx
  688. def get_latent(self, x):
  689. """Encode input to latent mean (deterministic, no sampling).
  691. Parameters
  692. ----------
  693. x : torch.Tensor
  694. Input gene expression, shape ``(batch_size, input_dim)``.
  696. Returns
  697. -------
  698. torch.Tensor
  699. Latent means, shape ``(batch_size, latent_dim)``.
  700. """
  701. self.eval()
  702. if self.raw_input:
  703. x = torch.log1p(x)
  704. encode = self.encoder(x)
  705. z_mu = self.z_mean(encode)
  707. return z_mu
  710. def get_latent_decode(self, z):
  711. """Decode latent vectors to gene expression space.
  713. Parameters
  714. ----------
  715. z : torch.Tensor
  716. Latent embeddings, shape ``(batch_size, latent_dim)``.
  718. Returns
  719. -------
  720. px_mu : torch.Tensor
  721. Reconstruction mean, shape ``(batch_size, input_dim)``.
  722. px_t : torch.Tensor or None
  723. Dispersion parameters, or None for normal distribution.
  724. """
  725. px = self.decoder(z)
  726. px_mu = self.px_mean(px)
  727. px_t = self.px_theta(px)
  729. if self.obs_dist == 'nb':
  730. px_mu = self.softmax(px_mu) * self.num_prototypes
  731. if self.nb_dispersion.startswith('celltype'):
  732. px_t = self.theta
  733. elif self.nb_dispersion == 'gene':
  734. px_t = self.px_theta(px)
  735. px_t = torch.mean(px_t, 0, True)
  736. else:
  737. raise NotImplementedError
  739. px_t = torch.clamp(px_t, min = EPS)
  740. else:
  741. px_t = None
  743. return px_mu, px_t
  746. def get_recon(self, x):
  747. """Reconstruct input via full encode-decode pipeline.
  749. Parameters
  750. ----------
  751. x : torch.Tensor
  752. Input gene expression, shape ``(batch_size, input_dim)``.
  754. Returns
  755. -------
  756. px_mu : torch.Tensor
  757. Reconstruction mean.
  758. px_t : torch.Tensor or None
  759. Dispersion parameters, or None for normal distribution.
  760. """
  761. self.eval()
  762. if self.raw_input: # raw: 1
  763. x = torch.log1p(x)
  765. encode = self.encoder(x)
  766. z_mu = self.z_mean(encode)
  767. z_logVar = self.z_log_var(encode)
  768. z = self.reparameterize(z_mu, z_logVar)
  770. px_mu, px_t = self.get_latent_decode(z)
  771. return px_mu, px_t
  775. def get_log_likelihood(self, input, target=None):
  776. """Compute negative log-likelihood averaged over multiple samples.
  778. Samples 5 times with different random seeds and averages the
  779. negative binomial log-likelihood across samples.
  781. Parameters
  782. ----------
  783. input : torch.Tensor
  784. Input gene expression, shape ``(batch_size, input_dim)``.
  785. target : torch.Tensor, optional
  786. Ground truth labels, required when ``nb_dispersion`` is
  787. ``'celltype_target'``.
  789. Returns
  790. -------
  791. torch.Tensor
  792. Mean negative log-likelihood per cell, shape ``(batch_size,)``.
  794. Raises
  795. ------
  796. NotImplementedError
  797. If ``obs_dist`` is not ``'nb'`` or if ``target`` is required
  798. but not provided.
  799. """
  800. if self.obs_dist != 'nb':
  801. raise NotImplementedError
  802. elif self.nb_dispersion == 'celltype_target' and target is None:
  803. print("Provide target label for log-likelihood calculation due to your choice of dispersion")
  804. raise NotImplementedError
  805. self.eval()
  807. n_sample = 5
  808. ll_value = 0
  809. for i in range(n_sample):
  810. with torch.no_grad():
  811. seed_torch(torch.device(device), seed = i, msg=False)
  813. pred, px_mu, px_t, _, _, _ = self.forward(input)
  815. if self.nb_dispersion == 'celltype_target':
  816. # data target
  817. assert target is not None
  818. dispersion = F.linear(one_hot_encoder(target, self.num_classes), self.theta)
  819. dispersion = torch.exp(dispersion)
  820. elif self.nb_dispersion == 'celltype_pred':
  821. # pred target
  822. softmax_pred = F.softmax(pred, dim=1)
  823. max_index = torch.multinomial(softmax_pred, 1)
  824. dispersion = F.linear(one_hot_encoder(max_index, self.num_classes), self.theta)
  825. dispersion = torch.exp(dispersion)
  826. elif self.nb_dispersion == 'gene':
  827. dispersion = px_t
  828. else:
  829. raise NotImplementedError
  831. ll = -log_likelihood_nb(input, px_mu, dispersion)
  832. ll = torch.sum(ll, dim = -1)
  833. ll_value += ll
  835. del px_mu, px_t, dispersion, ll
  836. torch.cuda.empty_cache()
  838. return ll_value / n_sample
  841. def sample_recon(self, px_mu, px_t, sample_size):
  842. """Sample from the negative binomial reconstruction distribution.
  844. Uses a Gamma-Poisson compound to generate count samples.
  846. Parameters
  847. ----------
  848. px_mu : torch.Tensor
  849. Reconstruction mean.
  850. px_t : torch.Tensor
  851. Dispersion (concentration) parameter.
  852. sample_size : int
  853. Number of samples to draw.
  855. Returns
  856. -------
  857. torch.Tensor
  858. Sampled counts, shape ``(sample_size, ..., input_dim)``.
  859. """
  860. concentration = px_t
  861. rate = px_t / px_mu
  862. # Gamma(alpha, beta: rate = 1/scale)
  863. gamma_d = Gamma(concentration=concentration, rate=rate)
  864. p_means = gamma_d.rsample((sample_size,))
  865. l_train = torch.clamp(p_means, max=1e8)
  866. counts = Poisson(l_train).sample() # (n_samples, n_cells, n_vars)
  867. return counts

model.py at commit 90c2678, under MIT · at the source

Overview

Authors: Kaiyun Guo1, Jiarui Ding1
ORCID iDs: Kaiyun Guo, Jiarui Ding
  1. Department of Computer Science, University of British Columbia, Vancouver, BC V6T 1Z4, Canada
Institutions: University of British Columbia (Canada)
Journal: Cell genomics, volume 6, issue 6, article 101217
Dates: received 8 May 2025; accepted 17 March 2026; published online 16 April 2026; in print June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.xgen.2026.101217 · PMID 41997134 · PMCID PMC13261663 · OpenAlex W7154597936
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), human (organism), cellular / molecular (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Machine learning, Connectivity
Keywords: single-cell RNA sequencing, cell state, rare cell type, prototypical network, self-explaining model, disentanglement, layer-wise relevance propagation, prototypical relevance propagation, deep generative models, variational autoencoder
MeSH: Single-Cell Gene Expression Analysis*, Animals, Genomics, Humans (* major topic)
Journal subjects: Technology
Topic: Single-cell and spatial transcriptomics (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Natural Sciences and Engineering Research Council of Canada; University of British Columbia; Canadian Institutes of Health Research; Canada Research Chair Program; Canada Foundation for Innovation & John. R. Evans Leader Fund
Citations: not cited yet (Europe PMC); 96 references in the paper

Abstract

Cell type annotation is a fundamental task in single-cell genomics. Although various methods have been developed for automatic annotation, they often function as black-box models lacking explainability, proper uncertainty estimation, and robustness for rare cell types. We introduce ProtoCloud, a self-explanatory deep generative model that embeds cells into a structured, low-dimensional space organized around cell-type-specific prototypes. ProtoCloud matches or outperforms existing methods across 11 large-scale datasets, particularly for rare cell types. Its built-in uncertainty quantification mechanism, based on cell-prototype similarity, identifies and re-annotates misannotated training cells. By backpropagating cell prototype similarities to the gene space, ProtoCloud identifies key genes driving its classifications, facilitating the discovery of both known and novel marker genes. Applied to a time-course dataset of post-injury retinal neurons, ProtoCloud successfully annotates previously unassigned cells; in an esophageal cell atlas, it identifies rare but potentially important cell populations and their marker genes associated with esophageal inflammation.

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

Ding-Group/ProtoCloud

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 90c2678f9ce54e1e9911bd1aa5086c63a7798d89, 11 August 2026
Languages: Python (17), Jupyter (1)
Size: 50 files, 18 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, license file, environment (pyproject.toml), 1 notebook
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (10 files), PyTorch (10 files), pandas (9 files), scikit-learn (6 files), anndata (5 files), Scanpy (4 files), SciPy (4 files), Matplotlib (2 files), seaborn (2 files), h5py (1 file), UMAP (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
20 files
At the source: github.com/Ding-Group/ProtoCloud

Zenodo 18882740

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (8 files), pandas (8 files), PyTorch (8 files), scikit-learn (5 files), anndata (4 files), Scanpy (3 files), SciPy (3 files), Matplotlib (2 files), seaborn (2 files), h5py (1 file), UMAP (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers (HTTP 200)
  • 29 September 2026: the link answers (HTTP 200)
18 files
At the source: doi.org/10.5281/zenodo.18882740

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;
  • 34 scripts, each with its path and the digest of its content;
  • 21 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 and code availability

• All data used in this study are publicly available. The datasets used are available through their sources in the key resources table. • All original code has been deposited at https://github.com/Ding-Group/ProtoCloud and achieved in Zenodo (https://doi.org/10.5281/zenodo.18882740). • Any additional information required to reanalyze the data reported in this paper is available from the lead contact upon request.

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, issue, pages, dates, 2 authors, 10 keywords, 4 MeSH terms, 5 funders, 86 references.

Cite

This paper

Guo, K., & Ding, J. (2026). ProtoCloud: A prototypical self-explaining model for single-cell analysis. Cell genomics, 6(6), 101217. https://doi.org/10.1016/j.xgen.2026.101217

BibTeX

@article{guo2026protocloud,
author = {Guo, Kaiyun and Ding, Jiarui},
title = {{ProtoCloud: A prototypical self-explaining model for single-cell analysis}},
journal = {Cell genomics},
year = {2026},
month = apr,
volume = {6},
number = {6},
pages = {101217},
publisher = {Elsevier},
issn = {2666-979X},
doi = {10.1016/j.xgen.2026.101217},
url = {https://doi.org/10.1016/j.xgen.2026.101217},
pmid = {41997134},
pmcid = {PMC13261663}
}

RIS

TY - JOUR
AU - Guo, Kaiyun
AU - Ding, Jiarui
TI - ProtoCloud: A prototypical self-explaining model for single-cell analysis
T2 - Cell genomics
J2 - Cell Genom
PY - 2026
DA - 2026/04/16
VL - 6
IS - 6
SP - 101217
SN - 2666-979X
PB - Elsevier
DO - 10.1016/j.xgen.2026.101217
UR - https://doi.org/10.1016/j.xgen.2026.101217
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.xgen.2026.101217",
"type": "article-journal",
"title": "ProtoCloud: A prototypical self-explaining model for single-cell analysis",
"container-title": "Cell genomics",
"author": [
{
"family": "Guo",
"given": "Kaiyun"
},
{
"family": "Ding",
"given": "Jiarui"
}
],
"container-title-short": "Cell Genom",
"volume": "6",
"issue": "6",
"page": "101217",
"DOI": "10.1016/j.xgen.2026.101217",
"PMID": "41997134",
"PMCID": "PMC13261663",
"ISSN": "2666-979X",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.xgen.2026.101217",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
16
]
]
}
}

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.1093/nar/gkag706 [code]
scDifformer: diffusion-based post-training for virtual cell modeling across large-scale single-cell data.
Journal: Nucleic acids research
In common: UMAP, anndata, Scanpy, 8 other tools, 9 references
[2] doi:10.1038/s44320-026-00208-7 [code]
Interpretable deep generative ensemble learning for single-cell omics with Hydra.
Journal: Molecular systems biology
In common: UMAP, anndata, Scanpy, 8 other tools, cellular / molecular, 6 references
[3] doi:10.64898/2026.03.30.714220 [code]
An integrated single cell and spatial omics atlas of human prenatal development
Journal: bioRxiv (preprint)
In common: UMAP, anndata, Scanpy, 8 other tools, 5 references
[4] doi:10.1371/journal.pcbi.1014327 [code]
Supervised deep learning with gene functional annotation for cell classification.
Journal: PLoS computational biology
In common: anndata, Scanpy, h5py, 7 other tools, genetics / omics, cellular / molecular, 4 references
[5] doi:10.1038/s41467-026-71759-4 [code]
CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning.
Journal: Nature communications
In common: anndata, Scanpy, PyTorch, 6 other tools, cellular / molecular, 6 references
[6] doi:10.1016/j.isci.2026.116055 [code]
Mapping the transcriptional diversity of calcium signaling in the mouse and human brain.
Journal: iScience
In common: UMAP, anndata, Scanpy, 8 other tools, genetics / omics, 3 references
[7] doi:10.1093/bib/bbag490 [code]
Systematic benchmarking and optimal strategy selection of cross-species integration methods.
Journal: Briefings in bioinformatics
In common: anndata, Scanpy, seaborn, 5 other tools, genetics / omics, 6 references
[8] doi:10.1093/bioinformatics/btag652 [code]
mmVelo: a deep generative model for estimating cell state-dependent dynamics across multiple modalities.
Journal: Bioinformatics (Oxford, England)
In common: UMAP, anndata, Scanpy, 7 other tools, genetics / omics, 4 references
[9] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: UMAP, anndata, Scanpy, 7 other tools, genetics / omics, cellular / molecular, 3 references
[10] doi:10.1002/advs.77003 [code]
SemanticST: A Scalable Multi-Contextual Graph Learning Framework for Uncovering Spatial Niches and Robust Multi-Sample Integration in Spatial Transcriptomics.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: anndata, Scanpy, h5py, 7 other tools, genetics / omics, 4 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.