PhiFlow is a Python library for differentiable physics simulation, primarily targeting fluid dynamics, particle systems, and PDE-based optimization. It provides a unified field abstraction (CenteredGrid, StaggeredGrid, PointCloud, Mesh) with automatic resampling and boundary handling, enabling seamless integration with machine learning workflows. The library supports multiple backends (NumPy, PyTorch, TensorFlow, JAX) and features a rich geometry module, physics solvers (advection, diffusion, incompressible flow, SPH, waves), and visualization tools. While its core abstractions are clean and well-tested, the codebase exhibits some technical drift due to deprecated API surface, large monolithic Dash-based web UI, and heavy reliance on the external phiml tensor library. Nonetheless, it is actively maintained with extensive test coverage and a growing research community.
FTorch is a production-stable Fortran library that enables direct coupling of PyTorch machine learning models to Fortran scientific codes without requiring a Python runtime. It provides a comprehensive Fortran interface to LibTorch (PyTorch's C++ backend) for tensor operations, model inference, automatic differentiation, optimizers (SGD, Adam, AdamW), and loss functions (MSE, cross-entropy). The architecture uses a three-layer design: Fortran modules with derived types (torch_tensor, torch_model, torch_optim) that call a thin C API (ctorch.h/ctorch.cpp), which in turn wraps LibTorch. This layered approach isolates Fortran code from C++ ABI changes and allows the library to be built as a shared or static library with CMake, supporting CPU, CUDA, HIP, XPU, and MPS backends. The library includes extensive examples covering tensor manipulation, simple neural networks, ResNet-18 inference, batching, multi-I/O, looping, multi-GPU, MPI parallelism, autograd, and full training loops. Unit tests use pFUnit and integration tests are built from examples, with CI testing across multiple compilers (gfortran, ifx, flang) and platforms. A Python utility package (ftorch_utils) provides model conversion (PyTorch to TorchScript) and validation. FTorch is published in the Journal of Open Source Software (JOSS) and is used in several HPC climate and fusion simulation codes (E3SM, CAM, ICON, UKAEA). The codebase demonstrates strong engineering practices: fypp code generation reduces boilerplate for multiple tensor ranks and data types, C interoperability is handled cleanly via iso_c_binding, and finalizers ensure automatic resource cleanup. However, there are some maintenance risks including reliance on fypp preprocessing, a large CI matrix, and the need to track LibTorch releases. A legacy API (torch_tensor_from_array_legacy) is still present but deprecated. Overall, FTorch is a well-crafted, domain-specific library that fills a critical gap for Fortran-HPC users needing ML integration.
RUMUS is a native-Rust deep learning framework with a modular architecture including core tensor/autograd library, GPU backend via WebGPU (wgpu), neural network modules, optimizers, data loading, ONNX export, JIT kernel fusion, and subcrates for vision (CNN ops, INT4 quantization), graph neural networks (SpMM), distributed training (3D parallelism), and an inference server with continuous batching. The framework emphasizes memory safety, zero-copy view operations, borrow-safe optimizers (gradient draining mechanism), and supports both CPU and GPU computation. It includes advanced features like FlashAttention, block-quantized INT8/INT4 inference, deterministic fixed-point inference for zero-knowledge backend fixtures, and a custom ops plugin API for external WGSL kernels. The codebase is well-organized with clean abstractions (Backend trait, Module derive macro), but shows signs of incomplete pieces (distributed training may be partial, inference server model is mock) and minor code-README discrepancies (unsafe usage in mmap despite claims of zero unsafe).
This is the TensorFlow Model Garden, a large monorepo of model implementations, training loops, and research code. The dominant character is an application/framework: it provides official TF2 model code under `official/`, a custom training library under `orbit/`, and a large body of research code under `research/` and `community/`. The codebase is not a single deployable service but a collection of training/eval/export scripts, model factories, config systems, and data pipelines. It uses Gin configs, dataclass-based configs, and a registry pattern to compose models, tasks, and data loaders. Tests exist across the repo, and CI workflows are present. The repository is hybrid in that it contains research-oriented experiments and data-processing code, but the core is a software framework for building and training TensorFlow models.
InsightFace is a comprehensive, production-grade face analysis ecosystem. It provides a Python package (`insightface`) with high-level APIs for face detection, recognition, attribute estimation, and face swapping, backed by ONNX Runtime. A C++ SDK (`inspireface`) enables on-device inference across Linux, Android, iOS, and embedded platforms with support for CUDA, TensorRT, CoreML, and Rockchip NPUs. A FastAPI server offers REST endpoints for face search and verification with SQLite persistence and license management. A PySide6 desktop GUI (Evaluation Studio) provides interactive workflows for verification, album management, and enterprise evaluation. The repository also contains extensive research code for training face recognition models (ArcFace, Partial FC, VPL) across PyTorch, MXNet, OneFlow, and PaddlePaddle, as well as detection (SCRFD, RetinaFace), 3D reconstruction, and face parsing. While the core application components are well-engineered and actively maintained, the research subprojects vary in maturity and may rely on outdated frameworks.
Audiocraft is a research codebase from Meta (Facebook Research) for state-of-the-art audio generation, including MusicGen, AudioGen, MAGNeT, JASCO, MultiBand Diffusion, and AudioSeal watermarking. It provides training and inference pipelines for text-to-music, text-to-sound, music continuation, style transfer, and symbolic conditioning (chords, drums, melody). The repository is primarily a research library with extensive configuration-driven training (Hydra/Dora), evaluation metrics (FAD, KLD, CLAP, ViSQOL), and interactive Gradio demos. It is not a production application but a collection of models, solvers, and utilities for audio generation research. The codebase is well-structured with modular components (conditioners, codebook patterns, audio effects) and includes unit tests, but relies on internal datasets and cluster paths that limit full reproducibility. Pretrained models are available via HuggingFace Hub for inference.
pytorch-forecasting is a deep learning library for time series forecasting, providing implementations of state-of-the-art models such as Temporal Fusion Transformer, N-BEATS, N-HiTS, DeepAR, PatchTST, TiDE, TimeXer, and many others. Built on PyTorch and PyTorch Lightning, it offers a complete pipeline from data preprocessing (TimeSeriesDataSet, encoders, samplers) through model training (with GPU support, callbacks, hyperparameter tuning via optuna) to prediction and evaluation (point, quantile, and distributional metrics). The library supports multivariate forecasting, static and time-varying covariates, categorical features, and multiple targets. A major v2 refactoring is underway, introducing a new data module layer and simplified package interface, though the v2 API is explicitly marked as experimental and unstable. The codebase is well-tested with automated integration tests across all models and metrics, and employs a composition pattern for metrics (supporting weighting, aggregation, and distribution losses) and a layered architecture for models (base classes, package containers, building blocks).
Chai-1 is a molecular structure prediction tool that takes FASTA sequences (proteins, DNA, RNA, ligands, glycans) and predicts 3D structures using a diffusion model. It is packaged as a Python library with a CLI (`chai-lab fold`) and a Python API (`chai_lab.chai1.run_inference`). The pipeline ingests sequences, optionally generates MSAs via ColabFold server, loads templates from RCSB, computes ESM embeddings, applies user-defined restraints (contacts, pockets, covalent bonds), tokenizes all atoms, generates a rich set of features, collates them into batches, and runs a TorchScript diffusion model to produce multiple structure samples. Outputs are ranked by confidence metrics (pTM, ipTM, pLDDT, clash score) and saved as CIF files. The codebase is well-structured with clean abstractions (feature generators, data contexts, collation), strong typing (jaxtyping, beartype), and CI quality gates. It is a hybrid of a production-grade inference tool and research code, with some copied components (rigid transformations from AlphaFold, ColabFold MSA server) and a monolithic inference entry point. The repository is actively maintained with recent commits, PyPI releases, and comprehensive examples.
This repository implements a full PyTorch backend for Moore Threads MUSA GPUs, providing a drop-in replacement for `torch.cuda`. It enables PyTorch models to run on MUSA hardware with minimal code changes by registering a `PrivateUse1` device backend. The architecture consists of C++ ATen operator implementations (over 200 ops), wrappers around the proprietary muDNN deep neural network library, a core runtime layer (streams, events, caching allocator, IPC), distributed training via MCCL (MUSA Collective Communications Library), an Inductor compiler backend with Triton support, quantization (W4A16, int8), and profiling tools. Key entry points include `torch_musa/__init__.py` for autoload, `setup.py` for building, `torch_musa/csrc/core/MUSAHooksInterface.cpp` for device registration, and `torch_musa/csrc/aten/ops/` for operator implementations. Data flows follow PyTorch's dispatch mechanism: operations are routed to MUSA-specific kernels via the `PrivateUse1` dispatch key, with muDNN handling most deep learning primitives. External dependencies include PyTorch (patched for version 2.11.0), muDNN, MCCL, musolver, muFFT, and Triton. The repository also includes automated CUDA-to-MUSA porting tools (`tools/cuda_porting/`) and a comprehensive test suite covering operators, distributed training, quantization, and sparse tensors.
The Allegro package implements the Allegro E(3)-equivariant machine learning interatomic potential as an extension for the NequIP framework. It provides a neural network architecture that predicts energies and forces in atomic systems while being invariant to translations, rotations, and reflections. The model is built using a combination of scalar and tensor feature tracks, interacting through tensor product layers, and is designed to be strictly local with a configurable cutoff radius. The architecture centers around the `AllegroModel` function, which constructs a graph neural network. Input atomic data (positions, types, and optionally cell) is processed through embedding layers to generate initial scalar and tensor features. These features then pass through multiple Allegro layers, each consisting of tensor product operations (via the `Contracter` module) and mixing layers (MLPs). The final features are reduced to per-atom energies, summed to get the total energy, and forces and stresses are computed via automatic differentiation if requested. Key entry points include the `AllegroModel` function and the package's entry point for NequIP integration. The package relies on external dependencies such as NequIP, PyTorch, and e3nn, with optional accelerations via NVIDIA's CuEquivariance library or custom Triton kernels for GPU performance. The codebase demonstrates strong engineering practices, including performance optimizations for the tensor product bottleneck (through both the base `Contracter` implementation and GPU-accelerated variants), a clear modular structure, and comprehensive testing. Reusable components such as the `Contracter` and `MakeWeightedChannels` modules showcase efficient tensor product handling and feature weighting strategies that could be adapted to other equivariant neural network architectures with minimal modification.
graph_weather is a research-oriented deep learning library for weather forecasting with graph neural networks. It implements multiple model families—GraphCast-inspired encoder/processor/decoder models, the diffusion-based GenCast and GenDA, the ensemble FGN, WeatherMesh, Aurora, FengWu-GHR, and CaFA—along with a substantial set of data loaders, loss functions, training scripts, and evaluation utilities. The package is structured as a Python library with HuggingFace Hub model integration, PyTorch Lightning training support, and a comprehensive test suite, giving it a hybrid character: it is fundamentally research code, but packaged and tested with application-grade discipline. Entry points include GraphWeatherForecaster, GraphWeatherAssimilator, WeatherStationReader, and various dataset classes, while training scripts live under train/.
This repository is a curated list of academic papers on learning-based odometry, covering visual odometry (VO), visual-inertial odometry (VIO), inertial odometry, LiDAR odometry, semantic SLAM, and NeRF SLAM. It is organized as a README with tables detailing paper titles, venues, years, links to papers and code repositories, and short notes on each method. The list includes papers from 2015 to 2026 and is regularly updated with recent contributions. While no code or datasets are provided, the README serves as a comprehensive bibliography for researchers and practitioners in the field. It links to numerous external GitHub repositories and blogs for further exploration.
Fish Speech is a production-grade multilingual text-to-speech system with a dual-autoregressive transformer architecture (4B parameter slow AR for temporal semantics, 400M fast AR for residual codebooks). It supports real-time voice cloning from short reference audio (10-30s), multi-speaker multi-turn generation, and fine-grained prosody/emotion control via natural language tags. The system is deployed through multiple interfaces: a Gradio web UI, a React-based modern web UI, a production ASGI API server (Kui) with streaming support, and command-line tools for inference and batch processing. Its architecture is modular: a TTSInferenceEngine orchestrates reference loading, LLM inference, and VQ decoding; an RVQ audio codec (10 codebooks, ~21 Hz frame rate) compresses audio; and the dual-AR model is structurally isomorphic to standard LLMs, enabling reuse of inference optimizations like paged KV cache and RadixAttention. The repository also includes training infrastructure (Lightning + Hydra) with LoRA fine-tuning, protobuf-based dataset pipelines, and a comprehensive i18n framework. While primarily a deployable application, it retains strong research character with published papers, benchmark results, and custom model implementations.
ModelScope is a unified framework for model inference, training, and deployment across computer vision, NLP, audio, multi-modal, and scientific domains. It provides a registry-based architecture where models, pipelines, preprocessors, trainers, and metrics are registered by task and can be instantiated from configuration or directly via Python APIs. The framework integrates tightly with the ModelScope Hub for model and dataset distribution, supporting versioned model IDs and snapshot downloads. Key entry points include the `pipeline()` function for inference, `build_trainer` for training, and CLI tools for cache management and server deployment. The architecture is modular with well-defined base classes (TorchModel, Pipeline, Preprocessor, Metric, Hook) and a configuration system that drives component construction. External dependencies span PyTorch, TensorFlow, HuggingFace Transformers, MMDetection, Diffusers, and numerous domain-specific libraries. The codebase is large and actively developed, but shows signs of technical drift through duplicated research code, skipped tests, and legacy TensorFlow 1.x components.
PhySO (Physical Symbolic Optimization) is a Python library for symbolic regression using deep reinforcement learning, with a strong emphasis on physics-informed constraints such as dimensional analysis. It discovers closed-form analytical expressions from data, supporting both single-dataset symbolic regression (SR) and multi-dataset class symbolic regression (Class SR) where the same functional form is shared across realizations with per-dataset free constants. The core architecture consists of a token-based program representation (reverse Polish notation), a custom LSTM-based policy network, a modular prior system (hard/soft length, physical units, nesting limits), and an efficient batch execution engine with optional parallel free-constant optimization. The library provides high-level entry points (`physo.SR()` and `physo.ClassSR()`), configuration presets, and a toolkit for expression manipulation and random generation. It includes extensive benchmarking infrastructure (Feynman and Class benchmarks), demos for real-world problems (e.g., Milky Way streams, US tariffs), and unit tests. External dependencies include PyTorch, NumPy, SymPy, pandas, scikit-learn, and matplotlib. While primarily a software library for symbolic regression, it is deeply research-oriented with benchmark result CSVs and analysis scripts, giving it a hybrid application/research character.
BoltzGen is a deep learning pipeline for computational protein and peptide binder design. It provides a command-line interface (boltzgen) that orchestrates a multi-step workflow: diffusion-based backbone generation, inverse folding (sequence design given structure), folding with Boltz-2, affinity prediction, analysis, and filtering/ranking of designs. The system supports diverse protocols including protein, peptide, nanobody, antibody, and small-molecule targeting, with extensive conditioning options like binding sites, disulfide bonds, cyclization, and per-residue constraints. The codebase is structured as a Python package with modular components for data parsing (YAML design specs, mmCIF/PDB), featurization, tokenization, cropping, and model layers (pairformer, attention, diffusion, inverse folding). It includes training pipelines with Hydra configuration, PyTorch Lightning, and validation splits. While primarily an application, it also contains research-grade example datasets and a Jupyter notebook for filtering, reflecting its origin in a bioRxiv publication. The architecture is well-organized but shows some technical drift (hardcoded paths, print statements, broad exception handling) and dependency on specific CUDA versions.
Time-MoE is a library/framework for training and deploying time series foundation models using a Mixture-of-Experts (MoE) architecture. It provides tools for training the TimeMoE model from scratch or fine-tuning pretrained versions, evaluating on benchmark datasets, and generating forecasts. The codebase is organized into modules for models, datasets, training utilities, and I/O operations, with a clear separation of concerns. Key features include efficient handling of large sequential datasets via sharded binary files, a custom MoE layer with load balancing loss, and integration with Hugging Face Transformers for model management and generation.
This repository is a curated 'awesome list' of research resources on multimodal learning in medical imaging. It contains no application code, tests, or data pipelines; its sole substantive file is a large README.md that catalogs papers, datasets, benchmarks, and code repositories. Topics span medical vision-language models, report generation, visual question answering, retrieval-augmented generation (RAG), and multimodal LLMs. The list is organized by task and includes links to arXiv PDFs, GitHub code, and dataset sources, with badges indicating publication venues.
This repository provides PyTorch implementations of Google Research's MetNet family of models for short-term weather forecasting, including MetNet, MetNet-2, MetNet-3, MetNetPV (photovoltaic), and MetNetSingleShot. The codebase is structured as a Python package with modular layers (ConvGRU, ConvLSTM, CoordConv, FiLM conditioning, MaxViT, partition attention, etc.) and data preprocessing utilities (Gaussian satellite merging, point-to-grid translation, MRMS normalization). The models are designed to ingest satellite imagery and radar data and output precipitation or other weather variables. The repository also includes pretrained weights hosted on HuggingFace Hub and a test suite covering layers, data utilities, and model forward/backward passes. While primarily an application library, it contains reusable data engineering components for geospatial data fusion.
This is a research-grade PyTorch implementation of Danijar Hafner's Dreamer v4 model-based reinforcement learning algorithm. The core artifact is the `dreamer4` package, dominated by a monolithic `dreamer4/dreamer4.py` (~3000 lines) that implements `VideoTokenizer`/`SpaceTimeTokenizer`, `DynamicsWorldModel`, `AudioTokenizer`, and `StateTokenizer`. These classes build causal space-time transformers with separate space/time attention blocks, latent flow-matching diffusion with shortcut consistency, BYOL-style tokenizer pre-training, PoPE attention, and a large zoo of experimental loss terms (latent autoregressive loss, decorrelation, orthogonality, SigReg, self-flow distillation, shortcut loss). `dreamer4/trainers.py` provides training loops (VideoTokenizerTrainer, BehaviorCloneTrainer, DreamTrainer, SimTrainer) and `dreamer4/cli.py` exposes CLI entry points for training and serving the world model. The repository is hybrid: primarily research code, but packaged and tested like a library. It ships a pyproject.toml with pinned dependencies, a parametrized test suite (tests/test_dreamer.py, test_e2e.py, test_env_wrapper.py), a browser-based Snake environment with a Flask-style server (`dreamer4/web_env/`) used for human demonstration collection and replay-buffer inspection, and environment wrappers in `dreamer4/env.py` that record agent experience to folders or memmap replay buffers. Root-level scripts are the actual experiment entry points, targeting standard benchmarks: HalfCheetah (imagination RL), CartPole (dynamics + RL), MovingMNIST (tokenizer + dynamics), and Snake (PPO with dynamics model). Craftsmanship is above typical research code: clean package layout, pytest coverage across many hyperparameter combinations, self-contained utilities (LossNormalizer, tensor pack/unpack helpers, with_seed decorator, memmap replay-buffer helpers), and HuggingFace Accelerate integration for distributed/mixed-precision training. However, the single-file core, 100+ hyperparameter flags on trainers, scattered hard-coded constants, sparse docstrings, and reliance on volatile niche packages (x-transformers, h-net-dynamic-chunking, PoPE_pytorch, adam-atan2-pytorch) make long-term stability and code reuse risky. The repository is recently committed and appears maintained, but it is explicitly beta-status experimental research code, not a production system.