OSCR

Hi-Compass: a depth-aware deep learning framework for predicting cell-type-specific 3D genome organization from single-cell to spatial resolution.

Code ↔ Paper

15 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 15 matches
  1. [1] § Methods › Bulk ATAC-seq data processing ↔ hicompass/preprocess/atac.py, lines 299–375 · score 0.73 · bedGraph, BigWig, genomecov, bedtools, pipeline, BAM
  2. [2] § Methods › Model architecture ↔ hicompass/predicting/blocks.py, lines 95–129 · score 0.72 · DNAEncoder, ReLU, feature weighting, channel, batch, modules
  3. [3] § Methods › Meta-cell strategy and meta-cell Hi-C prediction ↔ hicompass/preprocess/atac.py, lines 299–375 · score 0.72 · bedGraph, BigWig, genomecov, bedtools, bw, bam
  4. [4] § Methods › Model architecture ↔ hicompass/predicting/blocks.py, lines 34–92 · score 0.68 · ATACDepthEncoder, depth feature, depth range, embedding, module
  5. [5] § Methods › Model training strategy ↔ hicompass/train/HicompassTrain.py, lines 206–283 · score 0.67 · cross entropy losses, MSE loss, SSIM, batch, training, model
  6. [6] § Results › Hi-Compass enables Hi-C prediction from multi-depth ATAC-seq data ↔ hicompass/predicting/PredictDataset.py, lines 64–205 · score 0.64 · DNA sequences, sequencing depth, genomic features, generalized CTCF, ATAC seq, error
  7. [7] § Results › Hi-Compass enables Hi-C prediction from multi-depth ATAC-seq data ↔ hicompass/predicting/PredictDataset.py, lines 64–205 · score 0.62 · DNA sequence, sequencing depth, genomic features, generalized CTCF, ATAC seq, genome
  8. [8] § Methods › Performance comparison with previous methods ↔ hicompass/train/HicompassModel.py, lines 47–114 · score 0.61 · AdaptiveAvgPool2d, insulation score, PyTorch, diagonal, models, training
  9. [9] § Methods › Model architecture ↔ hicompass/train/HicompassModel.py, lines 47–114 · score 0.60 · ResNet, adaptive, PyTorch, decoder, discriminator, modeling
  10. [10] § Results › Hi-Compass enables Hi-C prediction from multi-depth ATAC-seq data ↔ hicompass/train/HicompassTrain.py, lines 206–283 · score 0.60 · cross entropy, information weighted, discriminator, MSE, SSIM, loss
  11. [11] § Methods › Hi-C data processing ↔ hicompass/preprocess/hic_norm.py, lines 147–227 · score 0.58 · kb resolution, contrast stretching, mouse, human, hg38, optimize
  12. [12] § Results › Systematic evaluation of Hi-Compass performance ↔ hicompass/preprocess/hic_norm.py, lines 450–557 · score 0.56 · upper triangle, lower triangle, contrast stretched, bands, diagonals, Window
  13. [13] § Methods › Hi-C prediction and integration ↔ hicompass/predicting/utils.py, lines 113–178 · score 0.53 · create_cooler, prediction window, matrix, resolution, chromosomes, Hi
  14. [14] § Results › Hi-Compass enables Hi-C prediction from multi-depth ATAC-seq data ↔ hicompass/train/HicompassDataset.py, lines 535–581 · score 0.53 · DNA sequence, genomic features, generalized CTCF, ATAC seq, genome, depth
  15. [15] § Methods › CTCF ChIP-seq data processing ↔ hicompass/preprocess/atac.py, lines 272–297 · score 0.50 · bedGraph

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 · 545 lines · 20 KB · MIT · 3 matches

  1. #!/usr/bin/env python3
  2. """
  3. ATAC-seq preprocessing for Hi-Compass training data preparation.
  5. This module handles:
  6. 1. Stratified subsampling from bulk ATAC-seq BAM files
  7. 2. Conversion to BigWig format with proper chromosome filtering
  8. 3. Hierarchical directory organization for training data
  9. """
  11. import os
  12. import subprocess
  13. from pathlib import Path
  14. from typing import List, Optional, Union
  15. import logging
  17. logging.basicConfig(
  18. level=logging.INFO,
  19. format='%(asctime)s - %(levelname)s - %(message)s'
  20. )
  21. logger = logging.getLogger(__name__)
  24. class ATACPreprocessor:
  25. """Preprocesses ATAC-seq data for Hi-Compass training."""
  27. def __init__(
  28. self,
  29. input_bam: Union[str, Path],
  30. cell_type: str,
  31. output_dir: Union[str, Path],
  32. chrom_sizes: Union[str, Path],
  33. genome: str = 'hg38',
  34. depth_mode: str = 'range',
  35. depth_list: Optional[List[Union[int, float]]] = None,
  36. min_depth: float = 2e5,
  37. max_depth: float = 2e7,
  38. step: float = 2e4,
  39. seed: int = 114514,
  40. keep_intermediate: bool = False
  41. ):
  42. """
  43. Initialize ATAC preprocessor.
  45. Args:
  46. input_bam: Path to input BAM/SAM file (bulk ATAC-seq)
  47. cell_type: Cell line name (e.g., 'GM12878', 'K562')
  48. output_dir: Output directory for processed files
  49. chrom_sizes: Chromosome sizes file (e.g., hg38.chrom.sizes)
  50. genome: Genome build ('hg38', 'mm10', etc.) for chromosome filtering
  51. depth_mode: 'range' or 'list' for depth specification
  52. depth_list: Custom depths (for 'list' mode)
  53. min_depth: Minimum depth (for 'range' mode, default: 2e5)
  54. max_depth: Maximum depth (for 'range' mode, default: 2e7)
  55. step: Step size (for 'range' mode, default: 2e4)
  56. seed: Random seed for reproducibility
  57. keep_intermediate: Keep intermediate files (BAM, bedGraph)
  58. """
  59. self.input_bam = Path(input_bam)
  60. self.cell_type = self._sanitize_cell_type(cell_type)
  61. self.output_dir = Path(output_dir)
  62. self.chrom_sizes = Path(chrom_sizes)
  63. self.genome = genome
  65. self.depth_mode = depth_mode
  66. self.depth_list = [int(d) for d in depth_list] if depth_list else None
  67. self.min_depth = int(min_depth)
  68. self.max_depth = int(max_depth)
  69. self.step = int(step)
  70. self.seed = seed
  71. self.keep_intermediate = keep_intermediate
  73. # Define valid chromosomes based on genome
  74. self._set_valid_chromosomes()
  76. self.output_dir.mkdir(parents=True, exist_ok=True)
  77. self._validate_inputs()
  78. self._total_reads = None
  80. def _set_valid_chromosomes(self):
  81. """Set valid chromosome names based on genome build."""
  82. if self.genome == 'hg38':
  83. # Human: chr1-22, chrX, chrY
  84. self.valid_chroms = set([f'chr{i}' for i in range(1, 23)] + ['chrX', 'chrY'])
  85. elif self.genome == 'mm10':
  86. # Mouse: chr1-19, chrX, chrY
  87. self.valid_chroms = set([f'chr{i}' for i in range(1, 20)] + ['chrX', 'chrY'])
  88. else:
  89. # For custom genomes, read from chrom_sizes file
  90. logger.warning(f"Custom genome '{self.genome}' - will use all chromosomes from chrom_sizes")
  91. self.valid_chroms = None # Will be set from chrom_sizes file
  93. @staticmethod
  94. def _sanitize_cell_type(cell_type: str) -> str:
  95. """Sanitize cell type to valid filename characters."""
  96. import re
  97. return re.sub(r'[^a-zA-Z0-9_-]', '_', cell_type)
  99. def _validate_inputs(self):
  100. """Validate inputs and check required tools."""
  101. if not self.input_bam.exists():
  102. raise FileNotFoundError(f"Input BAM not found: {self.input_bam}")
  103. if not self.chrom_sizes.exists():
  104. raise FileNotFoundError(f"Chrom sizes not found: {self.chrom_sizes}")
  106. # Load valid chromosomes from chrom_sizes if not set
  107. if self.valid_chroms is None:
  108. self.valid_chroms = set()
  109. with open(self.chrom_sizes, 'r') as f:
  110. for line in f:
  111. chrom = line.strip().split('\t')[0]
  112. self.valid_chroms.add(chrom)
  113. logger.info(f"Loaded {len(self.valid_chroms)} chromosomes from {self.chrom_sizes.name}")
  115. # Validate depth configuration
  116. if self.depth_mode == 'list':
  117. if not self.depth_list:
  118. raise ValueError("depth_list required for mode 'list'")
  119. if any(d <= 0 for d in self.depth_list):
  120. raise ValueError("All depths must be positive")
  121. elif self.depth_mode == 'range':
  122. if self.min_depth >= self.max_depth:
  123. raise ValueError("min_depth must be < max_depth")
  124. else:
  125. raise ValueError(f"Invalid depth_mode: {self.depth_mode}")
  127. # Check required tools
  128. required_tools = ['samtools', 'bedtools', 'bedGraphToBigWig']
  129. missing_tools = []
  130. for tool in required_tools:
  131. if subprocess.run(['which', tool], capture_output=True).returncode != 0:
  132. missing_tools.append(tool)
  134. if missing_tools:
  135. raise EnvironmentError(
  136. f"Required tools not found: {', '.join(missing_tools)}\n"
  137. f"Please install: samtools, bedtools, bedGraphToBigWig (UCSC tools)"
  138. )
  140. def _get_total_reads(self) -> int:
  141. """Count total reads in BAM file."""
  142. if self._total_reads is None:
  143. logger.info("Counting reads in input BAM...")
  144. result = subprocess.run(
  145. ['samtools', 'view', '-c', str(self.input_bam)],
  146. capture_output=True, text=True, check=True
  147. )
  148. self._total_reads = int(result.stdout.strip())
  149. logger.info(f"Total reads in {self.input_bam.name}: {self._total_reads:,}")
  150. return self._total_reads
  152. @staticmethod
  153. def _format_depth(depth: int) -> str:
  154. """
  155. Format depth as scientific notation (e.g., 1e5, 2e6, 2.1e5).
  157. Examples:
  158. 100000 -> '1e5'
  159. 210000 -> '2.1e5'
  160. 2000000 -> '2e6'
  161. """
  162. exp = 0
  163. value = float(depth)
  164. while value >= 10:
  165. value /= 10
  166. exp += 1
  168. if value == int(value):
  169. return f"{int(value)}e{exp}"
  170. return f"{value:.1f}e{exp}".rstrip('0').rstrip('.')
  172. def _generate_filename(self, depth: Union[int, str], extension: str) -> str:
  173. """
  174. Generate standardized filename: {CellType}~ATAC~{Depth}.{ext}
  176. Examples:
  177. GM12878, 210000, 'bw' -> 'GM12878~ATAC~2.1e5.bw'
  178. K562, 'bulk', 'bam' -> 'K562~ATAC~bulk.bam'
  179. """
  180. if isinstance(depth, int):
  181. depth_str = self._format_depth(depth)
  182. else:
  183. depth_str = depth
  184. return f"{self.cell_type}~ATAC~{depth_str}.{extension}"
  186. def _get_depth_dir(self, depth: Union[int, str]) -> Path:
  187. """
  188. Get subdirectory for a specific depth.
  190. Creates hierarchical structure:
  191. output_dir/
  192. └── CellType~ATAC~Depth/
  193. ├── CellType~ATAC~Depth.bam
  194. ├── CellType~ATAC~Depth.sorted.bam
  195. ├── CellType~ATAC~Depth.bedgraph
  196. ├── CellType~ATAC~Depth.sorted.bedgraph
  197. └── CellType~ATAC~Depth.bw
  198. """
  199. if isinstance(depth, int):
  200. depth_str = self._format_depth(depth)
  201. else:
  202. depth_str = depth
  204. depth_dir = self.output_dir / f"{self.cell_type}~ATAC~{depth_str}"
  205. depth_dir.mkdir(parents=True, exist_ok=True)
  206. return depth_dir
  208. def get_target_depths(self) -> List[int]:
  209. """Get list of target depths based on configuration."""
  210. if self.depth_mode == 'list':
  211. depths = sorted(self.depth_list)
  212. else:
  213. depths = list(range(self.min_depth, self.max_depth + 1, self.step))
  215. logger.info(f"Target depths: {len(depths)} levels")
  216. return depths
  218. def subsample_bam(self, target_depth: int) -> Path:
  219. """
  220. Subsample BAM to target depth using samtools.
  222. Args:
  223. target_depth: Target number of reads
  225. Returns:
  226. Path to subsampled BAM in depth-specific subdirectory
  227. """
  228. total_reads = self._get_total_reads()
  230. if target_depth >= total_reads:
  231. logger.warning(
  232. f"Target {target_depth:,} >= total {total_reads:,}, using full BAM"
  233. )
  234. return self.input_bam
  236. fraction = target_depth / total_reads
  238. # Get depth-specific directory
  239. depth_dir = self._get_depth_dir(target_depth)
  240. output_bam = depth_dir / self._generate_filename(target_depth, 'bam')
  242. logger.info(f"Subsampling to {target_depth:,} reads (fraction={fraction:.6f})")
  244. # Format for samtools -s: seed.fraction
  245. fraction_str = f"{fraction:.10f}"
  246. if fraction_str.startswith('0.'):
  247. fraction_decimal = fraction_str[2:] # Remove "0."
  248. else:
  249. fraction_decimal = fraction_str
  251. fraction_decimal = fraction_decimal.rstrip('0') or '0'
  252. samtools_seed = f"{self.seed}.{fraction_decimal}"
  254. try:
  255. subprocess.run([
  256. 'samtools', 'view',
  257. '-s', samtools_seed,
  258. '-b', '-o', str(output_bam),
  259. str(self.input_bam)
  260. ], check=True, capture_output=True, text=True)
  262. logger.info(f"✓ Created: {output_bam.relative_to(self.output_dir)}")
  263. return output_bam
  265. except subprocess.CalledProcessError as e:
  266. logger.error(
  267. f"samtools failed: -s {samtools_seed}\n"
  268. f"stderr: {e.stderr}"
  269. )
  270. raise
  272. def _filter_bedgraph(self, input_bedgraph: Path, output_bedgraph: Path):
  273. """
  274. Filter bedGraph to keep only valid chromosomes.
  276. This is critical to prevent bedGraphToBigWig errors from non-standard
  277. chromosomes (e.g., chrM, random contigs, alt haplotypes).
  279. Args:
  280. input_bedgraph: Input bedGraph file (sorted)
  281. output_bedgraph: Output filtered bedGraph file
  282. """
  283. logger.info(f"Filtering chromosomes (keeping {len(self.valid_chroms)} standard chroms)...")
  285. filtered_lines = 0
  286. total_lines = 0
  288. with open(input_bedgraph, 'r') as infile, open(output_bedgraph, 'w') as outfile:
  289. for line in infile:
  290. total_lines += 1
  291. chrom = line.split('\t')[0]
  292. if chrom in self.valid_chroms:
  293. outfile.write(line)
  294. filtered_lines += 1
  296. kept_pct = (filtered_lines / total_lines * 100) if total_lines > 0 else 0
  297. logger.info(f" Kept {filtered_lines:,}/{total_lines:,} lines ({kept_pct:.1f}%)")
  299. def bam_to_bigwig(self, bam_file: Path, depth: Union[int, str]) -> Path:
  300. """
  301. Convert BAM to BigWig with chromosome filtering.
  303. Pipeline:
  304. 1. BAM -> sorted BAM (coordinate sorted)
  305. 2. sorted BAM -> bedGraph (coverage)
  306. 3. bedGraph -> sorted bedGraph (lexicographic sort)
  307. 4. sorted bedGraph -> filtered bedGraph (standard chroms only)
  308. 5. filtered bedGraph -> BigWig
  310. Args:
  311. bam_file: Input BAM file
  312. depth: Depth label (for directory structure)
  314. Returns:
  315. Path to output BigWig
  316. """
  317. depth_dir = self._get_depth_dir(depth)
  319. base = bam_file.stem
  320. sorted_bam = depth_dir / f"{base}.sorted.bam"
  321. bedgraph = depth_dir / f"{base}.bedgraph"
  322. sorted_bedgraph_temp = depth_dir / f"{base}.sorted.temp.bedgraph"
  323. sorted_bedgraph = depth_dir / f"{base}.sorted.bedgraph"
  324. bigwig = depth_dir / f"{base}.bw"
  326. try:
  327. # Step 1: Sort BAM by coordinates
  328. logger.info(f"[1/5] Sorting BAM...")
  329. subprocess.run([
  330. 'samtools', 'sort', '-o', str(sorted_bam), str(bam_file)
  331. ], check=True, capture_output=True)
  333. # Step 2: BAM to bedGraph (coverage)
  334. logger.info("[2/5] Converting to bedGraph...")
  335. with open(bedgraph, 'w') as f:
  336. subprocess.run([
  337. 'bedtools', 'genomecov', '-ibam', str(sorted_bam), '-bg'
  338. ], stdout=f, check=True)
  340. # Step 3: Sort bedGraph
  341. logger.info("[3/5] Sorting bedGraph...")
  342. with open(sorted_bedgraph_temp, 'w') as f:
  343. subprocess.run([
  344. 'sort', '-k1,1', '-k2,2n', str(bedgraph)
  345. ], stdout=f, check=True)
  347. # Step 4: Filter to standard chromosomes
  348. logger.info("[4/5] Filtering standard chromosomes...")
  349. self._filter_bedgraph(sorted_bedgraph_temp, sorted_bedgraph)
  351. # Step 5: bedGraph to BigWig
  352. logger.info("[5/5] Converting to BigWig...")
  353. subprocess.run([
  354. 'bedGraphToBigWig',
  355. str(sorted_bedgraph),
  356. str(self.chrom_sizes),
  357. str(bigwig)
  358. ], check=True, capture_output=True)
  360. logger.info(f"✓ Created: {bigwig.relative_to(self.output_dir)}")
  362. # Cleanup intermediate files
  363. if not self.keep_intermediate:
  364. for f in [sorted_bam, bedgraph, sorted_bedgraph_temp, sorted_bedgraph]:
  365. f.unlink(missing_ok=True)
  366. if bam_file != self.input_bam and bam_file.parent == depth_dir:
  367. bam_file.unlink(missing_ok=True)
  369. return bigwig
  371. except subprocess.CalledProcessError as e:
  372. logger.error(f"Conversion failed: {e}")
  373. if hasattr(e, 'stderr') and e.stderr:
  374. logger.error(f"stderr: {e.stderr}")
  375. raise
  377. def process(self, include_bulk: bool = True) -> List[Path]:
  378. """
  379. Process all target depths and optionally generate bulk BigWig.
  381. Directory structure created:
  382. output_dir/
  383. ├── CellType~ATAC~2.1e5/
  384. │ └── CellType~ATAC~2.1e5.bw
  385. ├── CellType~ATAC~4.2e5/
  386. │ └── CellType~ATAC~4.2e5.bw
  387. └── CellType~ATAC~bulk/
  388. └── CellType~ATAC~1.7e8.bw (actual depth in filename)
  390. Args:
  391. include_bulk: Also generate bulk BigWig from full BAM
  393. Returns:
  394. List of generated BigWig files
  395. """
  396. depths = self.get_target_depths()
  397. logger.info(f"\n{'='*70}")
  398. logger.info(f"Starting ATAC-seq preprocessing")
  399. logger.info(f"{'='*70}")
  400. logger.info(f"Cell type: {self.cell_type}")
  401. logger.info(f"Genome: {self.genome}")
  402. logger.info(f"Target depths: {len(depths)}")
  403. logger.info(f"Output: {self.output_dir}")
  404. logger.info(f"Structure: {self.cell_type}~ATAC~<depth>/")
  405. logger.info(f"{'='*70}\n")
  407. bigwig_files = []
  409. # Process subsampled depths
  410. for i, depth in enumerate(depths, 1):
  411. try:
  412. logger.info(f"\n[{i}/{len(depths)}] Processing depth: {depth:,}")
  413. logger.info(f"{'='*50}")
  414. bam = self.subsample_bam(depth)
  415. bw = self.bam_to_bigwig(bam, depth)
  416. bigwig_files.append(bw)
  417. except Exception as e:
  418. logger.error(f"Failed at depth {depth}: {e}")
  419. continue
  421. # Generate bulk BigWig
  422. if include_bulk:
  423. try:
  424. logger.info(f"\n[Bulk] Generating bulk BigWig...")
  425. logger.info(f"{'='*50}")
  427. # Get actual total reads
  428. bulk_depth = self._get_total_reads()
  429. logger.info(f"Bulk depth: {bulk_depth:,} reads")
  431. # Create bulk directory with 'bulk' label
  432. bulk_dir = self._get_depth_dir('bulk')
  434. # Generate filename with actual depth
  435. bulk_filename = self._generate_filename(bulk_depth, 'bam')
  436. bulk_bam = bulk_dir / bulk_filename
  438. # Copy original BAM to bulk directory
  439. logger.info("Copying input BAM to bulk directory...")
  440. subprocess.run(['cp', str(self.input_bam), str(bulk_bam)], check=True)
  441. logger.info(f"✓ Copied to: {bulk_bam.relative_to(self.output_dir)}")
  443. # Convert to BigWig (use actual depth for final filename)
  444. bulk_bw = self.bam_to_bigwig(bulk_bam, 'bulk')
  446. # Rename BigWig to include actual depth in filename
  447. # The bam_to_bigwig uses the BAM filename stem, so we need to rename
  448. final_bw_name = self._generate_filename(bulk_depth, 'bw')
  449. final_bw_path = bulk_dir / final_bw_name
  451. if bulk_bw != final_bw_path:
  452. bulk_bw.rename(final_bw_path)
  453. logger.info(f"✓ Renamed to: {final_bw_path.name}")
  454. bulk_bw = final_bw_path
  456. bigwig_files.append(bulk_bw)
  458. except Exception as e:
  459. logger.error(f"Failed to generate bulk: {e}")
  461. # Summary
  462. logger.info(f"\n{'='*70}")
  463. logger.info(f"✓ Processing Complete")
  464. logger.info(f"{'='*70}")
  465. logger.info(f"Generated {len(bigwig_files)} BigWig files:")
  466. for bw in bigwig_files:
  467. logger.info(f" • {bw.relative_to(self.output_dir)}")
  468. logger.info(f"\nOutput directory: {self.output_dir}")
  469. logger.info(f"{'='*70}\n")
  471. return bigwig_files
  474. def preprocess_atac(
  475. input_bam: str,
  476. cell_type: str,
  477. output_dir: str,
  478. chrom_sizes: str,
  479. genome: str = 'hg38',
  480. depths: Optional[List[Union[int, float]]] = None,
  481. min_depth: float = 2e5,
  482. max_depth: float = 2e7,
  483. step: float = 2e4,
  484. include_bulk: bool = True,
  485. **kwargs
  486. ) -> List[Path]:
  487. """
  488. Convenience function for ATAC-seq preprocessing.
  490. Example usage:
  491. # Using depth range
  492. bigwigs = preprocess_atac(
  493. input_bam='GM12878.bam',
  494. cell_type='GM12878',
  495. output_dir='data/ATAC/hg38',
  496. chrom_sizes='hg38.chrom.sizes',
  497. genome='hg38',
  498. min_depth=2e5,
  499. max_depth=2e7,
  500. step=2e4
  501. )
  503. # Using custom depth list
  504. bigwigs = preprocess_atac(
  505. input_bam='K562.bam',
  506. cell_type='K562',
  507. output_dir='data/ATAC/hg38',
  508. chrom_sizes='hg38.chrom.sizes',
  509. genome='hg38',
  510. depths=[1e5, 2.1e5, 5e5, 1e6]
  511. )
  513. Args:
  514. input_bam: Input BAM file path
  515. cell_type: Cell line name (e.g., 'GM12878', 'K562')
  516. output_dir: Output directory
  517. chrom_sizes: Chromosome sizes file
  518. genome: Genome build ('hg38', 'mm10', etc.)
  519. depths: Custom depth list (if provided, overrides range parameters)
  520. min_depth: Minimum depth for range mode (default: 2e5)
  521. max_depth: Maximum depth for range mode (default: 2e7)
  522. step: Step size for range mode (default: 2e4)
  523. include_bulk: Generate bulk BigWig (default: True)
  524. **kwargs: Additional arguments for ATACPreprocessor
  526. Returns:
  527. List of generated BigWig file paths
  528. """
  529. preprocessor = ATACPreprocessor(
  530. input_bam=input_bam,
  531. cell_type=cell_type,
  532. output_dir=output_dir,
  533. chrom_sizes=chrom_sizes,
  534. genome=genome,
  535. depth_mode='list' if depths else 'range',
  536. depth_list=depths,
  537. min_depth=min_depth,
  538. max_depth=max_depth,
  539. step=step,
  540. **kwargs
  541. )
  543. return preprocessor.process(include_bulk=include_bulk)

atac.py at commit 8ea1710, under MIT · at the source

Overview

Authors: Yuan-Chen Sun1, Wen-Jie Jiang2, Kang-Wen Cai1, Na-Na Wei3, Fu-Ting Lai4, Hao-Jie Wang1, Rui-Xiang Gao1, Ze-Yu Kuang4, Jia-Lu Zhou5, An Liu1, Han-Wen Zhu4, Yu-Juan Wang1, Ming Xu2,6, Hua-Jun Wu1,4,7
ORCID iDs: Wen-Jie Jiang, Hao-Jie Wang, Yu-Juan Wang, Ming Xu, Hua-Jun Wu
  1. Key laboratory of Carcinogenesis and Translational Research (Ministry of Education/Beijing), Peking University Cancer Hospital & Institute, Beijing, China
  2. Department of Cardiology and Institute of Vascular Medicine, Peking University Third Hospital, State Key Laboratory of Vascular Homeostasis and Remodeling, NHC Key Laboratory of Cardiovascular Molecular Biology and Regulatory Peptides, Beijing Key Laboratory of Cardiovascular Receptors Research, Peking University, Beijing, China
  3. Key laboratory of Carcinogenesis and Translational Research (Ministry of Education/Beijing), Department of Lymphoma, Peking University Cancer Hospital & Institute, Beijing, China
  4. Department of Biomedical Informatics, School of Basic Medical Sciences, Peking University Health Science Center, Beijing, China
  5. Department of Gynecology and Obstetrics, Chinese PLA General Hospital, Beijing, China
  6. Research Unit of Medical Science Research Management/Basic and Clinical Research of Metabolic Cardiovascular Diseases, Chinese Academy of Medical Sciences, Beijing, China
  7. Beijing Advanced Center of Cellular Homeostasis and Aging-Related Diseases, Center for Precision Medicine Multi-Omics Research, Institute of Advanced Clinical Medicine, Peking University, Beijing, China
Institutions: Peking University Cancer Hospital (China); Peking University (China); Peking University Third Hospital (China); Chinese PLA General Hospital (China); Chinese Academy of Medical Sciences & Peking Union Medical College (China)
Journal: Nature communications, volume 17, issue 1, article 5172
Dates: received 23 July 2025; accepted 2 April 2026; published online 14 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41467-026-71877-z · PMID 41980945 · PMCID PMC13250166 · OpenAlex W7154258860
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), human (organism), mouse (organism)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning
Keywords: Computational models, Machine learning, Epigenomics, Chromatin remodelling, Chromatin analysis
MeSH: Chromatin*, Deep Learning*, Genome*, Single-Cell Analysis*, Animals, Hippocampus, Humans, Mice (* major topic)
Topic: Single-cell and spatial transcriptomics (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: National Natural Science Foundation of China (National Science Foundation of China) (32470662, 32270683); Natural Science Foundation of Beijing Municipality (Beijing Natural Science Foundation) (5242006)
Citations: cited by 1 paper (Europe PMC); 71 references in the paper

Abstract

Three-dimensional genome organization controls cell-type-specific gene expression through chromatin interactions, yet systematic analysis across diverse cellular contexts remains limited by experimental constraints. Here we present Hi-Compass, a depth-aware deep learning framework that predicts cell-type-specific chromatin organization using only chromatin accessibility data as cell-type-specific input. By dynamically accommodating variability in sequencing depth, Hi-Compass enables robust predictions across the full spectrum of data scales, from sparse single-cell to high-coverage bulk profiles. Benchmarking shows that Hi-Compass achieves superior concordance with experimental Hi-C data compared to existing methods, with particularly strong recovery of high-confidence chromatin loops. Applied to peripheral blood and embryonic heart datasets, Hi-Compass resolves cell-type-specific chromatin interactions and systematically links disease-associated variants to putative target genes. The framework further enables spatially resolved chromatin interaction prediction in hippocampal tissue and demonstrates cross-species applicability through fine-tuning to mouse systems. Hi-Compass expands the capacity to study three-dimensional genome regulation across biological scales and species.

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

EndeavourSyc/Hi-Compass

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 8ea17100dbc8576a66248f47587cb987e3b7f102, 22 July 2026
Languages: Python (27)
Size: 33 files, 27 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (setup.py), documentation
Not found: CITATION.cff, tests, continuous integration
Tools: NumPy (13 files), PyTorch (10 files), pandas (8 files), scikit-image (5 files), Matplotlib (2 files), BEDTools (1 file), PyTorch Lightning (1 file), pysam (1 file), SAMtools (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
29 files
At the source: github.com/EndeavourSyc/Hi-Compass

Zenodo 19283061

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (13 files), PyTorch (10 files), pandas (8 files), scikit-image (5 files), Matplotlib (2 files), BEDTools (1 file), PyTorch Lightning (1 file), pysam (1 file), SAMtools (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers (HTTP 200)
  • 29 September 2026: the link answers (HTTP 200)
29 files
At the source:

Code availability

The Hi-Compass framework was implemented in the ‘hicompass’ Python package, which is available at https://github.com/EndeavourSyc/Hi-Compass. The specific version of the code associated with this publication is archived in Zenodo (10.5281/zenodo.19283061).

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

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

Data links

Data availability

The Hi-C, CTCF ChIP–seq and ATAC–seq datasets used in the study were all public data from the ENCODE (https://www.encodeproject.org/), 4DN (https://data.4dnucleome.org/) and GEO (https://www.ncbi.nlm.nih.gov/geo/) database, with the detailed information listed in the Supplementary Data 1-3. Cohesin HiChIP loop calls in GM12878 were obtained from Mumbach et al.43 and RAD21 ChIA-PET loops from Grubert et al.44 The single-cell ATAC-seq, Multiome and spatial ATAC-seq data were obtained from 10X Genomics (https://www.10xgenomics.com/datasets/), ENCODE and GEO database, with the detailed information listed in the Supplementary Data 4. GWAS SNPs data was obtained from GWAS Catalog70 (https://www.ebi.ac.uk/gwas/), eQTLs data from GTEx71 v10 (https://www.gtexportal.org/).

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, 14 authors, 5 keywords, 8 MeSH terms, 2 funders, 68 references.

Cite

This paper

Sun, Y.-C., Jiang, W.-J., Cai, K.-W., Wei, N.-N., Lai, F.-T., Wang, H.-J., Gao, R.-X., Kuang, Z.-Y., Zhou, J.-L., Liu, A., Zhu, H.-W., Wang, Y.-J., Xu, M., & Wu, H.-J. (2026). Hi-Compass: a depth-aware deep learning framework for predicting cell-type-specific 3D genome organization from single-cell to spatial resolution. Nature communications, 17(1), 5172. https://doi.org/10.1038/s41467-026-71877-z

BibTeX

@article{sun2026hi,
author = {Sun, Yuan-Chen and Jiang, Wen-Jie and Cai, Kang-Wen and Wei, Na-Na and Lai, Fu-Ting and Wang, Hao-Jie and Gao, Rui-Xiang and Kuang, Ze-Yu and Zhou, Jia-Lu and Liu, An and Zhu, Han-Wen and Wang, Yu-Juan and Xu, Ming and Wu, Hua-Jun},
title = {{Hi-Compass: a depth-aware deep learning framework for predicting cell-type-specific 3D genome organization from single-cell to spatial resolution}},
journal = {Nature communications},
year = {2026},
month = apr,
volume = {17},
number = {1},
pages = {5172},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-71877-z},
url = {https://doi.org/10.1038/s41467-026-71877-z},
pmid = {41980945},
pmcid = {PMC13250166}
}

RIS

TY - JOUR
AU - Sun, Yuan-Chen
AU - Jiang, Wen-Jie
AU - Cai, Kang-Wen
AU - Wei, Na-Na
AU - Lai, Fu-Ting
AU - Wang, Hao-Jie
AU - Gao, Rui-Xiang
AU - Kuang, Ze-Yu
AU - Zhou, Jia-Lu
AU - Liu, An
AU - Zhu, Han-Wen
AU - Wang, Yu-Juan
AU - Xu, Ming
AU - Wu, Hua-Jun
TI - Hi-Compass: a depth-aware deep learning framework for predicting cell-type-specific 3D genome organization from single-cell to spatial resolution
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/04/14
VL - 17
IS - 1
SP - 5172
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-71877-z
UR - https://doi.org/10.1038/s41467-026-71877-z
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-71877-z",
"type": "article-journal",
"title": "Hi-Compass: a depth-aware deep learning framework for predicting cell-type-specific 3D genome organization from single-cell to spatial resolution",
"container-title": "Nature communications",
"author": [
{
"family": "Sun",
"given": "Yuan-Chen"
},
{
"family": "Jiang",
"given": "Wen-Jie"
},
{
"family": "Cai",
"given": "Kang-Wen"
},
{
"family": "Wei",
"given": "Na-Na"
},
{
"family": "Lai",
"given": "Fu-Ting"
},
{
"family": "Wang",
"given": "Hao-Jie"
},
{
"family": "Gao",
"given": "Rui-Xiang"
},
{
"family": "Kuang",
"given": "Ze-Yu"
},
{
"family": "Zhou",
"given": "Jia-Lu"
},
{
"family": "Liu",
"given": "An"
},
{
"family": "Zhu",
"given": "Han-Wen"
},
{
"family": "Wang",
"given": "Yu-Juan"
},
{
"family": "Xu",
"given": "Ming"
},
{
"family": "Wu",
"given": "Hua-Jun"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "5172",
"DOI": "10.1038/s41467-026-71877-z",
"PMID": "41980945",
"PMCID": "PMC13250166",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-71877-z",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
14
]
]
}
}

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.1371/journal.pgen.1012081
ADNP regulates chromatin architecture and lineage fidelity during neural differentiation.
Journal: PLoS genetics
In common: mouse, 9 references
[2] doi:10.21203/rs.3.rs-9927928/v1 [code]
Genome-wide and allele-resolved maps of the radial architecture of the mouse genome
Journal: Research Square (preprint)
In common: pysam, BEDTools, SAMtools, 3 other tools, genetics / omics, mouse, 4 references
[3] doi:10.1101/gr.280394.124 [code]
De novo structural variants in autism spectrum disorder disrupt distal regulatory interactions of neuronal genes.
Journal: Genome research
In common: pysam, BEDTools, scikit-image, 3 other tools, 4 references
[4] doi:10.1038/s42003-026-10462-y [code]
SpaDC enables sequence-based integrative analysis and regulatory inference of spatial chromatin accessibility data.
Journal: Communications biology
In common: pysam, BEDTools, PyTorch, 3 other tools, genetics / omics, mouse, 3 references
[5] 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: pysam, PyTorch Lightning, BEDTools, 4 other tools, genetics / omics, mouse, 1 reference
[6] doi:10.1038/s41592-026-03057-2 [code]
CREsted: modeling genomic and synthetic cell-type-specific enhancers across tissues and species.
Journal: Nature methods
In common: pysam, BEDTools, PyTorch, 3 other tools, genetics / omics, mouse, 2 references
[7] doi:10.1016/j.celrep.2026.117110 [code]
Single-nucleus multiome analysis in the human prefrontal cortex identifies gene expression and cis-regulatory elements associated with aging.
Journal: Cell reports
In common: pysam, BEDTools, SAMtools, 4 other tools, genetics / omics, 1 reference
[8] doi:10.1038/s41586-026-10512-9 [code]
Astrocyte glucocorticoid receptor signalling restricts neuronal plasticity.
Journal: Nature
In common: pysam, BEDTools, SAMtools, 3 other tools, mouse, 2 references
[9] doi:10.1038/s41592-026-03211-w [code]
Spatial isoform sequencing at single-cell resolution reveals cell-type-specific spatial isoform variability in multiple brain cell types.
Journal: Nature methods
In common: pysam, BEDTools, SAMtools, 3 other tools, genetics / omics, mouse, 1 reference
[10] doi:10.1186/s13059-026-04177-w [code]
Genomic sequence evolution underlying human neocortical interareal diversification.
Journal: Genome biology
In common: pysam, BEDTools, SAMtools, 3 other tools, genetics / omics, mouse, 1 reference

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.