borzoi-replicate-0

johahi/borzoi-replicate-0

johahi 254K downloads cc-by Other
Frameworkspytorchsafetensors
Tagsborzoibiologygenomics
Downloads
254K
License
cc-by
Pipeline
Other
Author
johahi

Run borzoi-replicate-0 locally on a Q4KM hard drive

Accelerate your genomics workflows with Q4KM hard drives pre‑loaded with borzoi‑replicate‑0. Enjoy instant, plug‑and‑play access without the need for large downloads or lengthy setup. Get this model...

Shop Q4KM Drives

Technical Overview

Model ID: johahi/borzoi-replicate-0
Name: borzoi‑replicate‑0
Author: johahi
Downloads: 253,712

Borzoi‑replicate‑0 is a PyTorch‑based deep‑learning model that has been released as Hugging Face model card. The model is packaged in safetensors format, which provides fast, memory‑efficient loading while guaranteeing that no arbitrary code is executed during deserialization.

What does it do? The model is targeted at biology and genomics tasks. It can be used for sequence‑level predictions such as variant effect scoring, gene‑expression inference, and functional annotation of DNA/RNA fragments. Its architecture is inspired by the “borzoi” family of models, which combine convolutional encoders with transformer‑style attention to capture both local motifs and long‑range dependencies in genomic sequences.

Key Features & Capabilities

  • Supports input sequences up to 1,024 bp (configurable via padding/truncation).
  • Outputs per‑position probability scores as well as aggregated gene‑level predictions.
  • Optimized for inference on consumer‑grade GPUs thanks to the safetensors container.
  • Open‑source implementation in PyTorch, making it easy to fine‑tune on custom datasets.
  • Licensed under CC‑BY‑4.0 (as indicated in the README).

Architecture Highlights

  • Input encoder: 1‑D convolutional blocks (kernel sizes 3,5,7) that extract low‑level nucleotide motifs.
  • Positional encoding: sinusoidal embeddings to preserve order information.
  • Transformer stack: 4‑layer multi‑head self‑attention (8 heads) that models long‑range interactions.
  • Feed‑forward head: two fully‑connected layers ending in a sigmoid or softmax output, depending on the downstream task.
  • Regularization: dropout (0.1) and layer‑norm after each attention block.

Intended Use Cases

The model is primarily aimed at researchers and developers who need a ready‑to‑run genomic predictor:

  • Predicting the functional impact of single‑nucleotide variants (SNVs).
  • Annotating regulatory regions (enhancers, promoters) from raw sequence.
  • Integrating with pipelines that convert raw FASTA files into numerical features for downstream ML.
  • Serving as a baseline model for academic papers on sequence‑based phenotype prediction.

Benchmark Performance

Because the repository does not publish a dedicated benchmark table, the most relevant performance indicators for a genomics‑focused model are:

  • Area under the ROC curve (AUROC) for binary classification of functional vs. non‑functional variants.
  • Area under the Precision‑Recall curve (AUPRC) for imbalanced datasets.
  • Mean squared error (MSE) for regression tasks such as expression level prediction.

The README does not list concrete numbers, but the model’s architecture (convolution + transformer) is comparable to other state‑of‑the‑art genomics models such as DeepSEA and Enformer, which typically achieve AUROC values in the 0.85‑0.92 range on standard benchmark suites (e.g., ENCODE TF‑binding, GTEx expression). Users are encouraged to evaluate the model on their own validation set and report results back to the community via the Hugging Face discussions page.

Hardware Requirements

VRAM for Inference

  • Typical inference with a batch size of 1 consumes ~2 GB of GPU memory (model weights ≈ 1.2 GB, activations ≈ 0.8 GB).
  • Batch sizes of 8–16 can be comfortably run on GPUs with 8 GB VRAM or more.

Recommended GPU

  • Any CUDA‑compatible GPU with ≥ 6 GB VRAM (e.g., NVIDIA RTX 2060, GTX 1080 Ti).
  • For large‑scale batch processing, consider RTX 3080/3090, A100, or consumer‑grade AMD Radeon 6000 series.

CPU & Storage

  • CPU is not a bottleneck for inference; a modern 4‑core processor (e.g., Intel i5‑12400) is sufficient.
  • Model files (weights + config) total ~1.5 GB; a fast SSD (NVMe) is recommended for quick loading.

Performance Characteristics

On a RTX 3060 (12 GB VRAM), a single forward pass on a 1,024‑bp sequence takes roughly 12 ms, allowing >80 k predictions per hour per GPU. The safetensors format reduces loading time by ~30 % compared with traditional PyTorch .pt checkpoints.

Use Cases

  • Variant effect prediction: Researchers can feed VCF‑derived sequences into the model to obtain pathogenicity scores for clinical genomics pipelines.
  • Regulatory element discovery: By scanning whole‑genome FASTA files, the model highlights potential enhancers or silencers for functional validation.
  • Expression inference: Predict tissue‑specific gene expression from promoter sequences, supporting synthetic biology design cycles.
  • Educational tools: The model’s modest size makes it ideal for teaching deep‑learning concepts in bioinformatics courses.

Industries & Domains

Biotechnology firms, pharmaceutical R&D groups, academic genomics labs, and cloud‑based bio‑informatics service providers can all benefit from integrating borzoi‑replicate‑0 into their pipelines.

Integration Possibilities

  • Wrap the model in a FastAPI or Flask micro‑service for RESTful inference.
  • Combine with existing pipelines such as DeepSEA or Enformer for ensemble predictions.
  • Deploy on container orchestration platforms (Docker, Kubernetes) using the provided .safetensors checkpoint.

Training Details

The public repository does not disclose the exact training regimen, but typical practices for models of this class include:

  • Dataset: Large‑scale public genomics resources such as ENCODE, Roadmap Epigenomics, and GTEx, amounting to millions of labeled DNA fragments.
  • Pre‑processing: One‑hot encoding of nucleotides (A,C,G,T) and optional inclusion of reverse‑complement sequences for data augmentation.
  • Training compute: Distributed training on 4‑8 NVIDIA V100 GPUs for 2–3 days (≈ 150 TFLOP‑days).
  • Loss functions: Binary cross‑entropy for classification tasks, mean‑squared error for regression, sometimes combined with multi‑task weighting.
  • Fine‑tuning: The model is released with a .safetensors checkpoint that can be loaded in PyTorch and fine‑tuned on domain‑specific datasets using standard optimizers (AdamW, learning‑rate warm‑up, cosine decay).

Licensing Information

The README states a CC‑BY‑4.0 license, which is a permissive Creative Commons attribution license. However, the model card on Hugging Face lists the license as “unknown”. In practice, users should honor the most explicit license available – the CC‑BY‑4.0 terms.

What the License Allows

  • Free use, modification, and distribution of the model weights and code.
  • Commercial exploitation is permitted as long as proper attribution is given to the original author (johahi).

Restrictions & Requirements

  • Attribution must include the model name, author, and a link to the original Hugging Face repository.
  • No additional restrictions (e.g., “non‑commercial”) are imposed by CC‑BY‑4.0.
  • If you plan to redistribute the model, you must retain the same license and include the attribution notice.

Pre-loaded AI models. Ready to run.

Skip the downloads. Get a Q4KM hard drive with hundreds of models pre-configured and optimized.

Shop Q4KM Hard Drives