This repository is a collection of standalone examples demonstrating the MLX framework (Apple's machine learning framework for Apple Silicon). It covers a wide range of deep learning models including LLMs (Mistral, Mixtral, Llama, T5), image generation (Stable Diffusion, FLUX, CLIP), video generation (Wan2.1), audio (Whisper, MusicGen, EnCodec), segmentation (SAM), and more. Each example is self-contained with its own entry point (CLI or Python script), model conversion utilities, and often a training/fine-tuning script. The repository is primarily an application-focused showcase with some research elements (e.g., normalizing flows, GCN). Production entry points include `whisper/mlx_whisper/cli.py` for transcription, `flux/txt2image.py` for image generation, `video/wan2.1/txt2video.py` for video generation, and `lora/lora.py` for fine-tuning. All examples depend on the MLX library and often bundle conversion from PyTorch weights. The architecture is a flat collection of independent projects, not a unified framework, leading to some code duplication (e.g., T5 and EnCodec are copied into multiple directories). However, several components are well-crafted and reusable, notably the Whisper decoding pipeline, the LoRA adapter module, and the flow-matching samplers for diffusion models.
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.
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.
The CircuitNet repository provides an open-source dataset and associated code for machine learning in Electronic Design Automation (EDA). It focuses on four key EDA tasks: congestion prediction, design rule check (DRC) prediction, IR drop prediction, and net delay prediction. The repository includes scripts for extracting features from LEF/DEF files (via Innovus output), training and evaluating deep learning models (CNNs and GNNs) for these tasks, and utilities for data loading and model training. The dataset is distributed in multiple versions (CircuitNet-N28, N14, N45) and consists of preprocessed features and labels stored as NumPy arrays. The codebase is organized into modular components: feature extraction, task-specific model directories, and shared utilities. While the repository enables reproduction of published results, it relies on specific tool versions (Innovus) and has hardcoded paths, which may require adaptation for reuse in different environments.
This repository is a curated, actively-maintained personal knowledge base of academic paper reading notes, focused on systems for machine learning, cloud computing, and related areas. It is organized by conference venue (e.g., OSDI, SOSP, MLSys) and by topic (e.g., LLM systems, GPU sharing, memory disaggregation). The core content consists of markdown files with structured summaries (TL;DR, background, design, evaluation) and cross-linked topic aggregation pages. The repository is the source for a GitBook static site and includes scripts for building and serving that site, as well as utilities for PDF text extraction. While not a data pipeline or software application, it functions as a high-quality research resource with consistent formatting, curation guidelines, and reusable templates for note-taking and paper list organization.
HailoRT is a production runtime SDK for Hailo AI accelerators. It provides a C/C++ library (libhailort) for loading compiled HEF models, configuring network groups, managing virtual streams (vstreams), and executing synchronous/asynchronous inference on Hailo-8/10/15 devices over PCIe, USB, or Ethernet. The repository also contains a command-line tool (hailortcli) for scanning, benchmarking, power measurement, logging, and firmware control; Python bindings (pyHailoRT); a GStreamer plugin suite (hailonet, hailosend/hailorecv, hailodevicestats); and an RPC-based client/server layer (HRPC) that allows a remote hailo service to own devices and GenAI sessions. It is a hybrid repo in the sense that it includes tutorial notebooks and algorithm modules (NMS, tracking, quantization) that resemble research code, but the dominant character is a software application/SDK. The architecture is layered: a common OS abstraction layer (files, sockets, mmap, events, threads), a VDMA/driver layer for hardware DMA and streams, a core-op/resource-manager layer for memory planning and context switching, a net-flow pipeline layer for pre/post-processing (NMS, YOLO, softmax, quantization), and high-level APIs for infer models and GenAI (LLM/VLM/speech2text). The code uses an Expected monad instead of exceptions, pimpl idioms for ABI stability, buffer pools for high-throughput transfers, and protobuf serialization for HRPC. The codebase is large and professional, with strong modularization, but also carries noticeable internal debt: many HRT-TODO markers, duplicated pipeline construction, hardcoded sysfs/tmp paths, deprecated API overloads, and partial Windows/QNX platform stubs. Maintenance is active; the repo is versioned (v5.4.0) and recently committed. Technical drift is medium because core dependencies are current and the project is clearly under active commercial development, yet some legacy/deprecated surfaces and platform-specific ifdefs remain. As a library, meaningful inference requires Hailo hardware; the build is CMake-driven with external dependencies managed via CMake scripts.
Mage is an open-source data pipeline orchestration platform that combines a visual notebook-style editor with a production-grade scheduling and execution engine. The system enables users to build, run, and monitor data pipelines composed of Python, SQL, R, and dbt blocks. Architecturally, it is a full-stack web application with a Python backend (Tornado-based server, SQLAlchemy ORM, REST API) and a Next.js/React frontend with a custom component library. Key entry points include the CLI (`mage` command), the web UI served by `mage_ai/server/server.py`, and the API layer at `mage_ai/api/` which exposes CRUD resources for pipelines, blocks, runs, schedules, users, and integrations. Data flows center around pipeline execution: blocks are connected in a DAG, each block can be a data loader, transformer, or exporter. Execution is handled by a configurable executor (local, K8s, EMR, PySpark) and scheduled via a built-in scheduler or external triggers. The platform integrates with dozens of data sources and destinations through a Singer-based integration framework, supports streaming pipelines, and includes advanced features like RBAC, version control, AI-assisted pipeline generation, and a command center for global search. It depends heavily on external services such as cloud storage (S3, GCS, Azure), databases (PostgreSQL, BigQuery, Snowflake, etc.), and authentication providers (OAuth, LDAP, OIDC).
Deep Forest (DF21) is a Python library implementing the Deep Forest ensemble learning algorithm, which serves as an alternative to deep neural networks for tabular data. The system provides both classification (CascadeForestClassifier) and regression (CascadeForestRegressor) capabilities through a cascade of decision tree ensembles. Each cascade layer consists of multiple estimators (Random Forest and Extra Trees) whose out-of-bag predictions serve as augmented features for subsequent layers. The architecture includes feature binning for efficiency, early stopping mechanisms, support for custom estimators/predictors, and a partial mode for memory-efficient training on large datasets. The codebase is organized into modular components with clear separation of concerns, including dedicated modules for binning, estimation, layer management, tree implementation, and I/O operations.
This repository implements an automated trading bot for Kalshi prediction markets, leveraging AI models (primarily via OpenRouter) to make directional trading decisions. The system is built as an async Python application with a CLI entry point (`cli.py`), a Streamlit dashboard, and a paper trading mode. It supports multiple strategies: an AI-driven directional strategy using a multi-agent debate pipeline (bull/bear researchers, risk manager, trader), a conservative NO-side safe compounder, market making, and a unified trading system that dynamically allocates capital. The core data flow involves ingesting market data from the Kalshi REST and WebSocket APIs, persisting to SQLite, running AI inference through OpenRouter with fallback chains and cost tracking, executing trades via Kalshi's signed REST API, and monitoring positions with stop-loss/take-profit logic. Risk management is enforced through Kelly criterion position sizing, edge filtering, category scoring, portfolio enforcer, and cash reserves. The codebase also includes performance analysis jobs, a paper trading signal tracker with static HTML dashboard, and a comprehensive test suite. External dependencies include Kalshi API, OpenRouter (with optional xAI and Grok models), SQLite, Streamlit, and various async libraries (httpx, aiohttp, websockets).
ChefBoost is a Python library implementing decision tree algorithms (ID3, C4.5, CART, CHAID, regression) and ensemble methods (AdaBoost, Gradient Boosting, Random Forest). It provides a simple API for building models from pandas DataFrames and making predictions. The library handles both categorical and numerical features without requiring preprocessing. Architecture consists of modular components: main interface (Chefboost.py), utilities (commons/), core training algorithms (training/), and ensemble methods (tuning/). Key strengths include proper packaging, unit tests, documentation, and solutions to technical challenges like recursive multiprocessing. The implementation correctly follows standard ML algorithms while providing a usable framework for developers.
Paper2Code is a research system that automatically generates runnable code repositories from machine learning research papers. The core pipeline, PaperCoder, uses a multi-agent LLM architecture (planning→analysis→coding) implemented as a sequence of Python scripts orchestrated via shell commands. It accepts papers in PDF (converted to JSON via s2orc-doc2json), JSON, or LaTeX format, and produces a complete Python project with config, model definitions, training loops, and evaluation scripts. The codebase supports both OpenAI API (o3-mini by default) and open-source models via vLLM (e.g., DeepSeek-Coder-V2-Lite-Instruct). It includes a debug stage that iteratively fixes runtime errors using LLM-generated SEARCH/REPLACE patches, and an evaluation module that scores generated repositories (reference-free or reference-based) using LLM judgment. The repository also bundles the Paper2Code benchmark dataset (90 papers from top ML conferences with gold repositories) and prompts for evaluation. Although primarily an application, it has research artifacts (evaluation scripts, prompt templates, benchmark data) that give it a hybrid character.
Kanaries/Rath is an open-source augmented analytics BI platform that automates exploratory data analysis, causal discovery, and dashboard creation. It is a full-stack application with a React/TypeScript frontend (Vite, MobX, shadcn/ui) and multiple Python microservices (causal inference, narrative insight generation, database connectors). The system ingests data from files, databases (PostgreSQL, ClickHouse, MySQL, etc.), and REST APIs, then provides automated visualization (mega-automation), semi-automated exploration, causal analysis (PC, FCI, GES, XLearner), and interactive dashboard building. It also includes custom Vega renderers (WebGL, Painter) for high-performance chart rendering and an Electron desktop wrapper. While primarily an application, it contains significant data research components such as causal discovery algorithms, statistical insight detection, and text pattern extraction, making it a hybrid tool for both data exploration and advanced analytics.
FISSURE is a modular RF signal-intelligence and reverse-engineering framework. In production it provides a PyQt5 dashboard for spectrum survey, IQ capture/playback, burst conditioning, signal classification, protocol discovery, targeted transmission, and fuzzing across SDR hardware such as USRP, HackRF, LimeSDR, RTL-SDR, PlutoSDR, and bladeRF. It coordinates distributed sensor nodes through a HIPRFISR hub over ZMQ, integrates with TAK via Cursor-on-Target messaging, and supports plugin-based automation operations. The repository also contains a very large GNU Radio flow graph library (maintained for GR 3.8 and 3.10), custom OOT blocks for ADS-B, Bluetooth, ACARS, X10, Z-Wave, fuzzing, and wideband detection, plus packet-crafting and replay tooling for security research.
Diffgram is a full-stack data annotation platform designed for creating, managing, and reviewing annotations on images, video, audio, text, 3D point clouds, and geospatial data. The system is composed of multiple microservices: a Flask-based REST API (`default`), a background processing service (`walrus`) for media ingestion, export generation, and project migration, an event-driven action runner service (`eventhandlers`) that executes automated workflows (e.g., ML model inference, webhooks, exports), and a Vue 2 + Vuetify single-page application frontend. The backend uses PostgreSQL with SQLAlchemy ORM, RabbitMQ for async messaging, and supports multiple cloud storage backends (AWS S3, GCP, Azure, MinIO). Authentication supports OAuth2/Keycloak, API keys, and session cookies with fine-grained role-based permissions. The platform's core domain includes label schemas, attribute groups, instance templates, task/job management with review workflows, discussions/issues, and a custom query engine for filtering files by labels and attributes. It integrates with external AI services (HuggingFace, Vertex AI, Azure Text Analytics) and labeling vendors (Labelbox, Scale AI). The frontend provides rich annotation tools including 2D canvas (boxes, polygons, keypoints), 3D point cloud annotation with Three.js, audio waveform annotation, text token annotation, and geospatial tile annotation. A command pattern enables undo/redo for annotation actions. The codebase demonstrates solid engineering practices with clear separation of concerns, reusable patterns (strategy, observer, command, policy enforcer), and extensive test coverage (Cypress E2E, Jest unit tests, Python unittest). However, there are signs of technical drift: some outdated dependencies, mixed JavaScript/TypeScript in the frontend, and a few legacy modules marked as deprecated. The open-core model is evident from `OPENCORE - ADD` markers, suggesting proprietary extensions. Overall, Diffgram is a mature, actively maintained annotation platform suitable for teams building training data pipelines.
This repository is a self-paced learning roadmap for algorithmic trading, structured as a hierarchical collection of markdown files. It curates resources, certifications, and project ideas across artificial intelligence, computer science, mathematics, finance, cloud engineering, and software engineering. The repository is entirely documentation-driven; there are no executable applications, data pipelines, or machine learning models. Its primary value lies in its organized curriculum, reusable topic templates, and role-based learning paths (e.g., quant developer, algorithmic trader). While not a software project, it demonstrates high organizational craftsmanship through consistent documentation structure, templates, and CI/CD for link checking and diagram rendering.
This repository is a comprehensive educational resource for linear algebra and matrix computations, serving as the companion code for the book "Book 4: The Power of Matrices" from the "Iris Flower Book" series. It contains Jupyter notebooks and Streamlit apps that visualize core concepts from vectors and matrices to eigenvalue decomposition, SVD, and data projections. The code is pedagogical, using synthetic data and the Iris dataset to illustrate mathematical ideas through interactive plots and heatmaps. It is not a production application or data pipeline but a teaching tool. The repository is well-organized by chapter, though code is duplicated across notebooks rather than modularized, reflecting its educational nature.
This repository is an open-source textbook, 'Machine Learning Systems: Design and Implementation', produced as a static website via mdBook. It is not a running application or data pipeline; rather, it is a documentation project with a custom build toolchain that transforms Markdown chapters (with extended syntax for equations, citations, cross-references) into a bilingual HTML site. The primary code comprises Python scripts for preprocessing Markdown, assembling the publish tree, and ensuring resource symlinks, along with CI/CD workflows for testing and deployment to GitHub Pages. The content covers the full ML system stack including computational graphs, compilers, accelerators, distributed training, and model serving, with both English and Chinese editions. The repository is actively maintained with frequent commits, but technical drift exists due to pinned Python dependencies and incomplete migration to v2 (many chapter placeholders). It is hybrid in nature: primarily a documentation project, but with application-like build infrastructure and reusable preprocessing components.
nlpaug is a Python library for data augmentation across text (character, word, sentence), audio, and spectrogram modalities. It provides a wide array of augmentation techniques including random insertion/substitution/deletion, synonym replacement via WordNet/PPDB, contextual word embeddings (BERT, GPT-2, RoBERTa), back-translation, TF-IDF-based augmentation, keyboard/OCR error simulation, and audio effects (noise, pitch shift, speed, VTLP). The library follows a consistent pattern: each augmenter inherits from a base class, accepts data via a unified `augment()` method, and returns augmented samples. Composition is supported through `Sequential` and `Sometimes` pipeline classes. It relies heavily on external deep learning models (HuggingFace Transformers, word2vec, GloVe, fastText) and audio processing (librosa). The codebase is well-structured with clear separation of concerns (augmenters, models, utilities, flows), extensive unit tests, and documentation. However, it exhibits significant technical drift due to aggressively pinned dependencies (e.g., `transformers>=5.9.0`, `numpy>=2.4.6`) that may not exist or conflict with current stable releases, and some integration code (conda setup for Python 3.5–3.9) is outdated. Despite this, the core augmentation logic and utility modules are sturdy and reusable.
This repository is primarily an educational resource for teaching data science and machine learning concepts. It contains a extensive collection of Jupyter notebooks, Python scripts, and supporting materials covering topics from basic statistics and pandas to advanced deep learning, NLP, and LLMs. The content is organized as tutorials and examples rather than a cohesive application, with numerous datasets included for hands-on learning. The repository appears to be actively maintained with recent updates, suggesting efforts to keep the educational content current with evolving technologies.
face_recognition is a Python library and CLI toolkit that wraps dlib's deep-learning-based face recognition models behind a simple, high-level API. It provides functions to detect face locations (HOG or CNN-based), extract 68-point or 5-point facial landmarks, compute 128-dimensional face encodings, and compare faces via Euclidean distance. The package ships two Click-based CLI entry points — `face_recognition` for batch identification against a known-people folder and `face_detection` for locating faces in images — both supporting multiprocessing and tunable tolerance/upsample parameters. The core logic lives in `face_recognition/api.py`, which is essentially a thin, well-abstracted wrapper around dlib detectors, shape predictors, and the ResNet face encoder, with coordinate conversion helpers to keep the public API in (top, right, bottom, left) tuple form. The repo also includes a large examples directory (webcam recognition, KNN/SVM classifiers, blink detection, batch GPU inference, Flask web service, Raspberry Pi integration) and multi-stage Docker builds for CPU and GPU deployment. Last tagged release is 1.4.0 (2020); the final commit on master dates to mid-2026 but the project shows little active development and many open issues, placing it in 'stale' maintenance status. Technical drift is medium: the codebase still references Python 2.7 in places, pins older dlib versions in some Dockerfiles, and has CI only through 3.10, while the ecosystem has moved to Python 3.12+ and dlib 19.24+. The API wrapper itself is clean and reusable, but the CLI modules and examples are too tightly coupled to the library and filesystem assumptions to be extracted as standalone components.