Made With ML is an educational data science project that implements an end-to-end ML pipeline for classifying GitHub repositories into categories (NLP, computer vision, MLOps, other) based on their titles and descriptions. The core data lineage flows from raw CSV datasets (dataset.csv, holdout.csv) through text cleaning, tokenization via SciBERT, and stratified splitting into train/val/test sets, followed by distributed training with PyTorch and Ray Train, hyperparameter tuning via HyperOpt, evaluation with slice-based metrics using Snorkel, and serving through a FastAPI/Ray Serve deployment. The project demonstrates MLOps patterns including MLflow experiment tracking, data validation with Great Expectations, behavioral model testing, and CI/CD via GitHub Actions with Anyscale for cloud execution. The codebase is well-structured with clear separation of concerns across data.py, train.py, tune.py, evaluate.py, predict.py, serve.py, models.py, and utils.py. It includes comprehensive tests at the code, data, and model levels. However, the project shows signs of staleness with pinned dependencies from 2023 (Ray 2.7.0, transformers 4.28.1, torch 2.0.0) that have known security vulnerabilities and compatibility issues with current Python versions. The data pipeline components—particularly the CustomPreprocessor, stratified splitting, and text cleaning—are genuinely reusable patterns. The evaluation framework with slice-based metrics and behavioral tests (invariance, directional expectations, minimum functionality) represents solid ML engineering practice. The deployment configuration is tightly coupled to Anyscale's proprietary platform, limiting portability.
The repository provides the official PyTorch implementation of DoRA (Weight-Decomposed Low-Rank Adaptation), a parameter-efficient fine-tuning method. It integrates with Hugging Face PEFT and includes training/evaluation scripts for vision-language and language tasks (e.g., VQA, ScienceQA, commonsense reasoning). The architecture is modular, with core components like DoRA tuners, adapter controllers, and low-rank layers. Entry points include training scripts (finetune.py, train_dora.py), evaluation scripts (evaluate.py, run_llava.py), and serving tools (gradio_web_server.py). External dependencies include PyTorch, Transformers, PEFT, bitsandbytes, and dataset-specific libraries.
This repository is a comprehensive collection of examples, tutorials, and applications demonstrating how to use LanceDB (a vector database) for various AI/ML applications. It showcases patterns for retrieval-augmented generation (RAG), multimodal search, chatbots, recommendation systems, and AI agents. The repository contains both Python and JavaScript/TypeScript implementations, with many examples featuring web interfaces using Streamlit, Gradio, or React. While it serves as a valuable resource for learning LanceDB integration patterns, the quality varies across examples, and some content is marked as archived.
DeepOnto is a Python package for ontology engineering with deep learning, centered on ontology alignment (BERTMap) and subsumption inference (BERTSubs, OntoLAMA). It wraps the OWLAPI Java library through JPype to load, query, reason over, and prune OWL ontologies, and uses PyTorch/Hugging Face Transformers to train or apply BERT-based classifiers for mapping prediction and refinement. The package exposes config-driven pipelines (BERTMapPipeline, BERTSubs pipelines, OntoLAMA inference) plus evaluation utilities for OAEI-style benchmarks.
TorchFort is a library that bridges PyTorch with Fortran and C/C++ programs, primarily targeting HPC/scientific computing applications. It provides a C API that allows users to load PyTorch models (via TorchScript or built-in MLP), train them, and perform inference directly on user-provided arrays without data copying. The library supports supervised learning as well as reinforcement learning (RL) with several state-of-the-art algorithms: DDPG, TD3, SAC, and PPO. It includes comprehensive RL infrastructure such as replay buffers, rollout buffers, online running normalizers, and distributed training via MPI. Integration with Weights & Biases is available for experiment tracking. Architecturally, TorchFort consists of a thin C API layer, a set of C++ implementations using LibTorch, and Fortran bindings generated via ISO_C_BINDING. The core C++ code is organized into modules for model management, training, distributed communication, CUDA utilities, and RL subsystems. Configuration is externalized via YAML files, and the library is designed to be used as a static or shared library linked into user applications. Notable components include a prioritized replay buffer with sum-tree implementation (replay_buffer.h), an online running normalizer using Welford's algorithm with MPI synchronization (running_normalizer.h), and a tensor list abstraction for handling multiple typed arrays (tensor_list.h). The codebase demonstrates good engineering practices with extensive test coverage, error handling via return codes, and support for both CPU and GPU execution. While primarily an application/library for integrating PyTorch into HPC codes, the repository also contains research-quality RL algorithm implementations and data preprocessing components, giving it a hybrid character.
Spleeter is a Python library and CLI tool for music source separation, providing pretrained models to decompose audio tracks into stems (e.g., vocals, drums, bass, piano). The codebase is structured around a core Separator class backed by TensorFlow estimation, with abstract audio adapters (default FFMPEG), model providers (GitHub releases), and configuration loading from embedded or file-based JSON. The architecture supports both inference and training, with a well-defined pipeline for waveform loading, STFT computation, U-Net-based separation, and output saving. The library is designed for production use with multiprocessing support and Docker deployment. However, it relies heavily on deprecated TensorFlow 1.x APIs (tf.compat.v1, tf.estimator), indicating technical drift. The code is well-organized with clear separation of concerns, reusable components (audio adapter, model provider, utilities), and comprehensive test coverage.
OASIS is a Python framework for simulating social media platforms (Twitter, Reddit) populated by LLM-powered agents. It is designed for computational social science research, specifically studying information spread, opinion dynamics, group polarization, and the impact of platform algorithms. The system is built on top of the CAMEL AI framework for LLM interaction. The architecture follows a modular, event-driven pattern. The core simulation loop is managed by OasisEnv, which coordinates agents (SocialAgent), a platform (Platform), an async message channel (Channel), and a social graph (AgentGraph). Actions are generated by agents (either manually or via LLM calls), passed through the channel, and executed by the platform against a SQLite database. A recommendation system (Recsys) provides personalized content feeds using various strategies. The codebase is a hybrid of a software library and a research project. While the core framework is well-structured with clean abstractions (e.g., Channel, AgentGraph, Recsys), it carries significant research code debt: tight coupling to the fast-moving camel-ai framework, global state in recommendation modules, skipped tests, hardcoded paths in experiments, and mixed sync/async patterns. The extensive YAML-driven experiment configurations and visualization scripts are tightly coupled to specific research questions (misinformation, polarization) and datasets. Maintenance is active in the context of ongoing research, but the codebase shows signs of technical drift (skipped tests, commented-out features, dependency on specific LLM API patterns). It is a powerful tool for researchers but would require significant hardening for production use.
diart is a Python library and CLI tool for real-time online speaker diarization, built on top of pyannote.audio. It processes audio streams (microphone, files, WebSocket) with low latency using a modular pipeline of segmentation, embedding, clustering, and aggregation blocks. The library is designed for both streaming and offline evaluation, with support for overlap-aware processing and hyperparameter tuning via Optuna. It provides a reactive streaming architecture using RxPY, making it suitable for building AI-powered audio applications. The repository includes a benchmark suite, expected outputs for standard diarization datasets (AMI, DIHARD, VoxConverse), and CI/CD pipelines. While primarily a software library, it has a strong research component with published results and reproducibility artifacts.
This repository is a curated collection of Jupyter notebooks implementing core components of modern LLM architectures, intended for interview preparation. It covers attention mechanisms (MHA, GQA, MLA, KV-cache), normalization layers (LayerNorm, RMSNorm), functional components (RoPE, SwiGLU, LoRA, BPE, activation functions, cross-entropy, InfoNCE, sampling, quantization, SFT loss, tool calling parsing), and reinforcement learning losses (DPO, GRPO, DAPO, GSPO, KL divergence). Each notebook is a self-contained, minimal implementation of a specific algorithm, typically using PyTorch. The code is clean, concise, and well-commented, reflecting good engineering practices for educational purposes. While the repository is not a production application and lacks data pipelines, model training scripts, or continuous integration, it serves as a high-quality reference for understanding and reproducing the mathematical foundations of transformer-based language models. The hybrid nature lies in its focus on research-oriented ML components, but its structure is a pure code library rather than a data-driven research project.
Evo-1 is a research codebase for a lightweight Vision-Language-Action (VLA) model accepted at CVPR 2026. It provides a complete pipeline for training (two-stage pretraining + finetuning using DeepSpeed and InternVL3-1B backbone) and evaluating robot manipulation policies on simulation benchmarks (Meta-World, LIBERO, LIBERO-Plus, RoboTwin) and real robots (xArm6, Aloha, SO100). The primary data flow involves converting raw robot datasets (LeRobot v2.1 format) into normalized state/action pairs with delta-timestep support, computing per-dataset norm statistics, and training a flow-matching action head with a frozen VLM backbone. The repo also includes a WebSocket-based inference server and clients for real-robot deployment. Although the core is research-oriented, it incorporates the full LeRobot framework for data collection and robot control, giving it a hybrid character. The codebase is well-structured with reusable components for dataset processing, normalization, and video handling, but the embedded LeRobot copy and multiple evaluation environments introduce maintenance overhead.
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.
MockingBird is a Chinese voice cloning system implementing the SV2TTS (Speaker Verification to Text-to-Speech) framework. It provides a complete pipeline for few-shot voice cloning: a speaker encoder extracts d-vector embeddings from reference audio, a synthesizer (Tacotron with Global Style Tokens or VITS) converts text to mel-spectrograms conditioned on the speaker embedding, and a vocoder (HiFi-GAN, Fre-GAN, or WaveRNN) generates waveforms. It also includes a PPG-based voice conversion path using a Conformer-based PPG extractor and a PPG2Mel converter. The system supports multiple Chinese datasets (aidatatang_200zh, magicdata, aishell3, data_aishell) and provides web UIs (Streamlit/FastAPI), a PyQt5 toolbox, and CLI tools for training and inference. The codebase is a fork of Real-Time-Voice-Cloning adapted for Mandarin with significant additions including VITS synthesizer, multiple vocoder options, emotion extraction via wav2vec2, and a modern web API layer. While the original author has moved to a commercial product (noiz.ai), the repository shows recent commits (2026) and maintains a large community (36k stars).
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.
AutoKeras is an automated machine learning (AutoML) library built on Keras 3, designed to make deep learning accessible to non-experts. It provides high-level task-specific APIs (e.g., ImageClassifier, TextClassifier, StructuredDataClassifier) that automate neural architecture search and hyperparameter tuning. The core architecture uses a modular block-based system—blocks (e.g., DenseBlock, ConvBlock, ResNetBlock) are composed into a graph via a functional API, and a tuner (Greedy, Bayesian, Hyperband, Random) searches for the best model. The library includes a data preprocessing pipeline (Pipeline, HyperPipeline), adapters for input/output conversion, and serialization for model persistence. While primarily an application library, it also contains research-oriented components like benchmark experiments and tuner implementations, reflecting its academic origins. Key entry points are the AutoModel class and task classes, which expose fit/predict/evaluate workflows similar to Keras.
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.
HunyuanVideo-1.5 is an open-source video generation model by Tencent, implemented as a Python library with CLI scripts for inference (`generate.py`) and training (`train.py`). It generates high-quality videos from text or image prompts using a diffusion transformer (DiT) architecture with 8.3B parameters, supporting resolutions up to 1080p via super-resolution. The codebase provides a modular pipeline (`HunyuanVideo_1_5_Pipeline`) that orchestrates prompt encoding (byT5 text encoder, SigLIP vision encoder), denoising with flow matching, and VAE decoding. It includes advanced features like SSTA (Selective and Sliding Tile Attention) for efficient long-video processing, step distillation, CFG distillation, and various caching mechanisms (DeepCache, TeaCache, TaylorCache). The repository also offers a training script with distributed support (FSDP, context parallelism), LoRA fine-tuning, and the Muon optimizer. While primarily an application for video generation, it contains research-grade model implementations and evaluation benchmarks. The code is well-structured with reusable neural network modules, but relies on many optional hardware-specific dependencies (flash-attn, flex-block-attn, SageAttention) and external services for prompt rewriting, which may introduce operational complexity. The license is a custom Tencent Hunyuan Community License with restrictions.
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.
IgGM is a generative foundation model for antibody and nanobody design, implemented as a deep learning library with a command-line interface. The system performs tasks such as CDR loop design, framework region redesign (humanization), inverse design from complex structures, affinity maturation, and structure prediction. It uses a diffusion-based approach to co-design amino acid sequences and 3D backbone structures, leveraging an ESM2-based protein language model, Evoformer blocks with triangular attention, invariant point attention, and a structure module similar to AlphaFold2. The pipeline is orchestrated by the `AbDesigner` class and invoked via the `design.py` script, accepting PDB and FASTA inputs and generating output sequences and structures. The repository includes well-structured reusable components for rigid-body transformations (Rotation, Rigid), PDB parsing, coordinate conversion, and diffusion schedules, though some research artifacts (misspellings, commented code) and dependency pinning to older PyTorch/CUDA versions indicate moderate technical drift.