This repository contains the open-source book 'XQuant: 人人都是量化交易员' (XQuant: Everyone Can Be a Quantitative Trader), which serves as an educational resource for learning quantitative trading methodologies. Rather than being a functional trading application, it provides a structured curriculum teaching readers how to develop, test, execute, and monitor quantitative strategies using AI coding assistants. The book walks through a complete workflow: from selecting investment instruments (ETFs), determining position sizing, creating trading rules, validating strategy performance, avoiding overfitting, modeling execution costs, to monitoring and iterating on live strategies. Its unique value lies in teaching a spec-driven development approach where users write clear strategy specifications that AI coding assistants can translate into executable code, making quantitative research accessible to non-programmers.
Depth Anything V2 is a research codebase for monocular depth estimation, providing both relative and metric depth models. It builds on a DINOv2 encoder with a DPT decoder, offering four model scales (Small, Base, Large, Giant). The repository includes inference scripts for images and videos, a Gradio demo, and a subdirectory for fine-tuning on metric depth estimation using Hypersim (indoor) and Virtual KITTI 2 (outdoor) datasets. It also defines the DA-2K evaluation benchmark for relative depth. The code is well-structured with reusable transform utilities and evaluation metrics, but reproducibility is limited due to hardcoded dataset paths and unpinned dependencies. This is primarily a research project with a hybrid nature due to the included demo application.
This repository is a curated, structured list of 500+ AI startup market maps from 2024 to 2026, organized by quarter and subcategory (e.g., AI Agents, Compute, Healthcare). The primary artifact is a README.md with human-readable links, supplemented by a machine-readable CSV (`ai_market_maps.csv`), an RSS feed (`feeds/AIMarketMaps.xml`), and a Hugging Face dataset. The RSS feed is programmatically generated by `scripts/generate_rss.py`, which parses the README markdown and uses git history to assign publication dates. The repository serves founders, investors, and analysts by providing a comprehensive, frequently updated landscape of AI startup ecosystems. It is primarily a data curation and distribution project rather than a software application; the only code component is the RSS generation script and its associated CI workflow.
This repository is a comprehensive educational collection of algorithm problem solutions for LeetCode and Kamacoder (ACM mode), organized as a structured learning path for interview preparation. It contains over 350 Markdown files, each providing a detailed explanation, multiple solution approaches, and code in C++, Java, Python, Go, JavaScript, and many other languages. The content is purely pedagogical and static—not a runnable application or a data pipeline. It serves as the online companion to the '代码随想录' (programmercarl.com) book and video series. The repository demonstrates high consistency in formatting and pedagogical templates, but it is not software engineering; the 'craftsmanship' lies in the educational structure rather than in software architecture. It is hybrid in the sense that some files include empirical complexity analysis, but the dominant character is an educational resource.
This repository is a curated list of awesome downloadable SVG/PNG/Font icon projects, organized as an awesome list in README.md. It serves as a resource for developers seeking icon libraries, categorized into general purpose icons, logos, special icons, and other categories (CSS-only, paid, frameworks). The list is static content with no data processing or transformation. The project includes contribution guidelines and a code of conduct to manage community submissions. Quality is maintained via a GitHub Actions workflow that runs awesome-lint on pull requests and pushes, ensuring the list adheres to awesome list guidelines (proper formatting, no duplicates). This workflow is a reusable pattern for other awesome list projects. While the repository does not contain complex software or data pipelines, it demonstrates a lightweight, maintainable approach to curating technical resources. The workflow uses actions/checkout@v2 (slightly outdated) and awesome-lint via npm. The project shows active maintenance with recent commits and issue engagement, though the dependency management lacks exact version pinning.
This repository is a comprehensive, educational collection of 42+ Jupyter notebooks and runnable scripts demonstrating a wide array of Retrieval-Augmented Generation (RAG) techniques. It is primarily a data_research and educational resource, not a deployable application or library. The codebase serves as a practical cookbook for engineers and researchers, covering the full RAG stack from basic chunking and retrieval (e.g., simple RAG, BM25) to advanced methods like GraphRAG, Self-RAG, HyDE, RAPTOR, and agentic RAG. It also includes a dedicated evaluation framework with notebooks and reusable scripts for measuring faithfulness, relevance, and correctness using tools like DeepEval and custom LLM judges. The architecture is modular, with a shared helper_functions.py providing common utilities for PDF loading, embedding, and retrieval, and an evaluation/ module offering reusable evaluation pipelines. The runnable scripts in all_rag_techniques_runnable_scripts/ provide cleaner, class-based implementations of the techniques that are more suitable for integration into other projects than the notebooks themselves. While the code is well-structured for an educational project and demonstrates high craftsmanship in its reusable components, it is not designed for production deployment. Reproducibility is limited by the lack of a pinned dependency file and reliance on external API keys. The repository is actively maintained and highly influential (29k+ stars), making it a valuable reference for anyone building or evaluating RAG systems.
Visual Spatial Tuning (VST) is a research framework for enhancing Vision-Language Models (VLMs) with human-like visuospatial abilities, from perception to reasoning. It implements a two-stage pipeline: supervised fine-tuning (SFT) on 4.1M spatial perception samples (VST-P) followed by reinforcement learning (RL) on 135K reasoning samples (VST-R). The framework extends to Vision-Language-Action (VLA) models for robotic manipulation evaluated on the LIBERO benchmark. The repository contains custom model implementations (Qwen2.5VL, Qwen3VL) with sequence parallelism and FSDP support, data preprocessing scripts, evaluation benchmarks (VSIBench, 3D object detection on SUN RGB-D, VLM benchmarks), and a distributed RL training system (verl) with reward functions and advantage estimation. While primarily a research codebase, it includes production-quality training infrastructure and reusable data utilities. The code is actively maintained with recent commits, but has medium technical drift due to tight version pinning and reliance on an internal ByteDance framework (VeOmni) that is not publicly available, which may hinder full reproducibility.
The KhronosGroup/glTF-Sample-Assets repository contains a comprehensive collection of sample assets for the glTF (GL Transmission Format) specification. The repository is primarily used for testing and demonstrating the capabilities of glTF, including various features such as animations, physics, and materials.
This repository is the companion code for the second edition of Aurélien Géron's 'Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow'. It consists of 19 Jupyter notebooks that teach a wide range of machine learning and deep learning topics, including classification, regression, neural networks, CNNs, RNNs, NLP, reinforcement learning, and scalable deployment. The code is well-structured and annotated, designed for interactive learning. While not a production application, the notebooks contain several high-quality, reusable components such as custom Keras layers, training loops, and learning rate schedulers. The repository also includes Docker configurations and environment files to ensure reproducibility. However, the second edition is explicitly outdated, with libraries pinned to versions from 2021 (TensorFlow 2.6, Scikit-Learn 1.0), and the README directs users to the third edition and a PyTorch version. The data sources are standard benchmark datasets bundled as static files or downloaded from URLs that may change.
The Prompt Engineering Guide is a comprehensive, multilingual documentation site built with Next.js and Nextra that serves as an educational resource for prompt engineering with large language models. While the site itself is a web application, its core value lies in the extensive collection of tutorials, technique explanations, model-specific guides, and research summaries that constitute a structured knowledge base on effective LLM prompting. The repository includes interactive Jupyter notebooks that demonstrate practical applications of techniques like PAL, RAG, and ReAct, alongside hundreds of MDX pages covering topics from basic prompting to advanced agent building. Content is available in numerous languages, reflecting a commitment to global accessibility. The site features custom UI components for enhanced usability, such as announcement bars, course promotions, and copy-to-clipboard functionality, but these serve primarily to facilitate access to the educational content. Despite being actively maintained, the guide faces challenges typical of rapidly evolving fields: content requires frequent updates to keep pace with new LLM releases and research findings, and the multilingual nature increases the risk of translation drift. External links to papers, videos, and tools may also become stale over time. Nevertheless, the repository remains a valuable reference for practitioners and researchers seeking to understand and apply prompt engineering principles.
The Little Book of ML Metrics is a comprehensive, collaboratively authored reference book that explains and visualizes evaluation metrics across the full spectrum of machine learning tasks: regression, classification, clustering, ranking, computer vision, NLP, generative AI, probabilistic estimation, bias/fairness, and data observability. The repository contains the LaTeX source code, a collection of Jupyter notebooks (and Python scripts) that generate all figures, and a set of custom tools for book production and review. Its primary function is to produce a high-quality, print-ready PDF that serves as both a pedagogical introduction and a practical decision guide for practitioners. The codebase is dominated by figure-generation scripts that implement each metric with synthetic or small real-world datasets and render Tufte-style, publication-quality plots. While the repository is not a traditional software application, it does include several bespoke tools: an interactive formula tuner (for adjusting TikZ arrow annotations on formulas), a review recorder (a local HTTP server for reviewing the PDF with audio notes), and a formula layout helper that auto-positions arrows. These tools are tightly integrated into the book production pipeline but are not intended for general reuse. The code is well-organized and follows consistent visual patterns (shared color palette, despine helpers, direct annotations), though there is considerable duplication across notebook scripts and a lack of automated tests. The LaTeX build process is robust but depends on a full TeX distribution and a third-party GitHub Action. Dependencies are pinned via pyproject.toml and uv.lock, and the genai figure generation requires a separate heavy environment (torch, transformers) run manually, which reduces full reproducibility out-of-the-box. Overall, this is a well-crafted book project with strong internal consistency, but its code is best viewed as supporting infrastructure rather than a standalone piece of software.
This repository is an educational tutorial series that teaches how to build a nanoGPT-like transformer language model from scratch using PyTorch. It consists of over 30 Jupyter notebooks (with both TODO exercises and answer keys) designed for Google Colab, covering topics from token embeddings and positional encodings to multi-head attention, transformer blocks, training loops, scaling experiments, and instruction tuning. The code is modular, with separate classes for each component (TokenEmbedding, PositionEmbedding, AttentionHead, MultiHeadAttention, FeedForward, TransformerBlock, VocabularyLogits, nanoGPT, DataLoader, Trainer, ModelConfig), making it a valuable learning resource. Training is demonstrated on the Shakespeare dataset and later on a sample of FineWeb-Edu, with experiments on model size, learning rate, and tokenization. While the repository is not a production data pipeline or deployable application, it exhibits strong data/research characteristics through its focus on model training, scaling laws, and loss analysis. The notebooks are well-structured for self-paced learning but rely on Colab-specific workflows and hardcoded data URLs, limiting portability.
Repository of structured JSON datasets containing football match fixtures and results across major European leagues (English Premier League, Bundesliga, Serie A, La Liga, UEFA Champions League) spanning 2011-2027. Files are auto-generated from upstream Football.TXT text sources via a GitHub Actions workflow that refreshes data daily. Each league/season file follows a consistent schema: a top-level object with league metadata and a `matches` array containing per-match objects with round, date, teams, and score objects (half-time, full-time, optionally extra time and penalties). The repository is purely a data source - no application code, scripts, tests, or configuration beyond the JSON files. Raw GitHub links serve as a free public API for web applications, mobile apps, prediction models, or analytics pipelines. The data is clean and machine-readable but lacks schema validation, versioning, and formal documentation. Known issues include schema drift across seasons (missing half-time scores, awarded matches with `status: 'awarded'`, team name variations) that downstream consumers must handle defensively. The primary value is the breadth and consistency of match data across 15+ leagues and 15+ seasons, making it suitable for football statistics applications, prediction models, or league visualization tools. The auto-update pipeline keeps current seasons fresh, but upstream Football.TXT sources may not be maintained for older seasons, and the lack of schema enforcement risks silent data drift. This is a data_research repository - a data source rather than an application - with no executable code or processing pipeline present.
SimScale is a research codebase for data-driven, non-reactive autonomous vehicle simulation and benchmarking, developed by OpenDriveLab. It provides a comprehensive pipeline for training and evaluating end-to-end driving policies on the nuPlan/OpenScene dataset, with support for synthetic data augmentation (SimScale) and multiple agent architectures including Transfuser, DiffusionDrive, and GTRS-Dense. The repository implements a Plan-Do-Measure (PDM) closed-loop scoring framework, metric caching, and a Hydra-based configuration system for flexible experiment management. While primarily a research platform, it includes production-like training scripts, evaluation pipelines, and submission tools for the NAVSIM v2 challenge. The codebase is heavily coupled to the nuPlan ecosystem and requires large-scale data downloads (>1TB), but offers reusable components such as abstract agent interfaces, feature/target builders, and batch IDM policies. It is actively maintained with recent commits and a growing community of extensions.
ScenarioNet is a data-centric toolkit for managing and converting autonomous driving datasets into a unified scenario format. It provides converters for Waymo, nuScenes, nuPlan, Argoverse 2, VoD, and procedural generation (PG) datasets, transforming raw data into a common ScenarioDescription structure compatible with the MetaDrive simulator. The repository includes dataset management operations (merge, split, filter, copy), verification tools (existence and simulation checks), and utilities for handling scenario metadata. While it contains training and evaluation scripts for machine learning models, its primary focus is on data preparation and scenario engineering for autonomous driving research. The data lineage involves ingesting raw datasets via dataset-specific toolkits, extracting scenario elements (object tracks, map features, traffic signals, timestamps), and serializing them into pickle-based dataset structures with mapping and summary files. These outputs enable downstream tasks such as multi-dataset aggregation, scenario filtering for ML training, simulation-based validation, and dataset splitting. The toolkit addresses research questions around dataset scalability, scenario diversity, and reproducible evaluation of autonomous driving systems by providing a standardized interface across heterogeneous data sources. Key reusable components include the modular converter utility for multiprocessing data transformation, generic dataset operations (merge/split/copy) that operate on the standardized scenario format, and a verification framework with parallel processing and error reporting. These components demonstrate solid data engineering practices but are tempered by dependency management issues (commented-out packages requiring manual installation), hardcoded paths in training scripts, and reliance on external SDKs that may introduce version drift.
Amphion is a comprehensive open-source research toolkit for audio, music, and speech generation, developed by OpenMMLab. It covers multiple generative tasks including text-to-speech (TTS), singing voice conversion (SVC), voice conversion (VC), text-to-audio (TTA), neural audio codecs, and vocoders. The codebase is organized around config-driven experiments (JSON + shell scripts) with modular base classes for trainers, datasets, and inference. It ingests a wide variety of public datasets (LJSpeech, LibriTTS, VCTK, M4Singer, Emilia, etc.) and provides extensive preprocessing pipelines for feature extraction (mel-spectrograms, F0, energy, phonetic alignments, self-supervised features from HuBERT/Whisper). The primary research focus is on high-quality, zero-shot, and controllable generation using architectures like diffusion models, flow matching, GANs, autoregressive transformers, and vector-quantized codecs. The repository also includes evaluation metrics (F0, energy, intelligibility, speaker similarity) and visualization tools (SingVisio). While primarily a research codebase, it includes inference scripts and Gradio demos for practical use. External dependencies include PyTorch, HuggingFace Transformers, WeNet, Descript Audio Codec, and various pretrained models.
This repository provides the Bench2Drive benchmark for closed-loop end-to-end autonomous driving, accepted at NeurIPS 2024 Datasets and Benchmarks Track. It includes a large-scale multi-modal dataset (up to 7.3TB) collected in the CARLA simulator, an evaluation suite with metrics like Driving Score and Success Rate, and baseline results for over 10 methods. The codebase is a hybrid of research data pipeline and application: the dataset generation and evaluation scripts form the core data_research component, while the B2DVisualize Flask app, scenario runner, and leaderboard evaluator provide application-like interfaces for interaction and reproducibility. Data lineage: raw simulation data (sensor recordings, ground truth annotations) is collected via data_collect.py, transformed into compressed archives with JSON manifests, and evaluated using the leaderboard pipeline that computes multiple ability metrics. The repository answers research questions about the effectiveness of end-to-end driving policies under diverse urban scenarios.
MiniMind-O is a research codebase for training and evaluating a small-scale (0.1B parameter) omni-modal language model that processes text, audio, and image inputs and generates text or streaming speech. The architecture uses a Thinker–Talker dual-path design with frozen external encoders (SenseVoice, SigLIP2, Mimi codec, CAM++) and trainable projectors, plus a Multi-Token Prediction (MTP) head for audio codec tokens. The repository includes a complete training pipeline (SFT with DDP, mixed precision, checkpointing), a comprehensive evaluation CLI, a Gradio web demo, and a real-time Flask WebSocket demo with VAD and ASR for near-duplex interaction. Data is stored in parquet format with pre-encoded audio codes, images, and speaker embeddings. The project is primarily research-oriented, aiming to provide a transparent, reproducible baseline for omni-modal models, but also includes application-like components for interactive demos.
SimpleFold is a research repository focused on protein structure prediction using flow-matching generative models. While it includes application-like features such as a CLI and inference scripts, its core architecture is designed for ML research, specifically training and evaluating large-scale diffusion transformers (FoldingDiT) on structural biology data. The codebase is hybrid in nature, combining rigorous data engineering pipelines (parsing MMCIF, filtering, tokenization) with standard deep learning frameworks (PyTorch Lightning, Hydra). It supports dual backends (PyTorch and MLX) for inference, indicating a focus on accessibility across hardware platforms. The repository's primary value lies in its data processing pipeline, which is heavily adapted from the Boltz-1 project. It handles complex structural data (PDB, SwissProt, AFESM) through a modular pipeline including parsing, filtering, and tokenization. The model architecture implements flow-matching with ESM-2 embeddings for sequence context. Evaluation metrics include pLDDT confidence, TM-score, and RMSD, typical for structural biology research. However, the codebase exhibits signs of research-to-production transition challenges. Hardcoded paths (e.g., `/mnt/task_runtime/...`) and reliance on external binaries (TMscore, OpenStructure) reduce portability. The data pipeline is a fork of an external project (`boltz`), introducing maintenance overhead for divergence. Despite these issues, the use of Hydra for configuration management and PyTorch Lightning for training orchestration demonstrates solid engineering practices for an ML research project.
NeuralGCM is a research-grade hybrid machine learning and physics-based atmospheric model for weather and climate simulation, implemented primarily in JAX and Haiku. The repository provides a well-structured library (`neuralgcm`) with a clean inference API (`PressureLevelModel`) that supports loading pretrained checkpoints, encoding ERA5-like data into the model's sigma-coordinate state, advancing the model in time, and decoding back to pressure-level output with xarray integration. The code is highly modular and configurable via the gin-config system, allowing flexible composition of encoders, decoders, advanced neural parameterization modules, stochastic random fields, and data transforms. The repository also includes reference training code (designated as pseudocode), paper configuration files, Jupyter notebooks demonstrating data preparation and model deep dives, and pre-trained deterministic and stochastic checkpoints at multiple resolutions. While the inference path is fully reproducible given the provided checkpoints and public ERA5 data, the training pipeline relies on internal Google infrastructure and proprietary code, limiting full reproducibility. The library demonstrates strong software engineering practices for a research codebase, with extensive unit tests, modular design, and clear versioning, though it exhibits some technical drift due to an ongoing migration of components to a separate repository (`terrax`) and the use of hardcoded normalization statistics tied to specific training datasets.