ASRT (Automatic Speech Recognition Toolkit) is a Chinese speech recognition system that provides both training and inference capabilities. It uses a deep CNN acoustic model with Connectionist Temporal Classification (CTC) and an N-gram language model based on a maximum entropy hidden Markov model. The system supports multiple backends (TensorFlow/Keras and experimental PyTorch) and can be trained on several Chinese speech corpora (THCHS30, ST-CMDS, etc.). It includes HTTP and gRPC servers for real-time inference, a speech recorder utility, and client libraries. The architecture is monolithic with separate scripts for training, evaluation, and serving. The codebase is functional but shows signs of technical drift, such as using deprecated Keras APIs (fit_generator) and hardcoded paths. The language model implementation is a notable highlight, offering a non-trivial statistical decoding approach. The repository is popular but has a single maintainer and a high number of open issues.
This repository is a comprehensive, curated bibliography for the field of dataset distillation, maintained by three researchers. It aggregates over 400 papers organized by methodology (gradient matching, distribution matching, generative approaches, etc.) and application domain (continual learning, privacy, medical, federated, graph, NLP, video, etc.). The project provides a GitHub Pages website (index.html) that renders the paper list with links to code, project pages, and BibTeX citations, plus a sidebar for navigation. Supporting Python scripts (transform_record.py, validate_articles.py, catch_latest.py) manage the data pipeline: parsing a custom update format, validating article records, and merging latest additions. The repository is a hybrid of a data curation project (structured paper database) and a static web application (client-side rendering). While the code is simple and functional, there are data quality issues such as trailing whitespace in URLs, mismatched citation keys, and future-dated entries, indicating manual update processes that are not fully automated. The project is actively maintained with frequent additions, but the lack of pinned dependencies and automated CI validation limits reproducibility.
Omnizart is an automatic music transcription (AMT) library that converts polyphonic audio into symbolic representations including pitched notes, drums, chords, vocal melody, and beat/downbeat. Built as a Python CLI tool with multiple subcommands (music, drum, chord, vocal, vocal-contour, beat, patch-cnn), it provides pre-trained TensorFlow models and supports custom training and feature extraction. The architecture follows a modular pattern with separate app, inference, features, labels, and prediction modules per task, all inheriting from common base classes (BaseTranscription, BaseDatasetLoader). While primarily an application library for end-to-end transcription, it has strong research components: it uses standard MIR datasets (MAESTRO, MusicNet, MedleyDB, etc.), implements state-of-the-art models (U-Net with ASPP, attention-based U-Net, PyramidNet, Chord Transformer), and includes custom feature extraction (CFP, CQT, chroma). The repository also bundles a JavaScript waveform playlist library for documentation demos. The codebase shows active maintenance (recent commits in 2026, CI testing up to Python 3.14) but has technical drift risks due to heavy reliance on TensorFlow 1.x compat layers, external dependencies (madmom, vamp), and known bugs in drum model training.
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.
FlexFlow Train is a deep learning framework that automatically parallelizes and distributes neural network training across GPU/CPU clusters. The system ingests models from PyTorch, Keras, ONNX, or its own C++ API, converts them into a computation graph, and then applies a multi-stage optimization pipeline: graph-level substitutions (pattern matching and rewriting), series-parallel decomposition, cost estimation, and machine mapping via MCMC or dynamic programming. The optimized parallel graph is executed on the Legion/Realm runtime, coordinating distributed tasks across devices. The codebase is organized as a C++ library with Python bindings, comprising ~3500 files including kernels, a compiler, graph utilities, and model definitions. While the core architecture demonstrates sophisticated engineering with extensive tests and reusable graph abstractions, the repository carries significant complexity from heavy template metaprogramming, two execution backends, and partially implemented CPU/HIP kernels, making it more suitable for integration by teams with C++ and distributed systems expertise.
GPT-SoVITS is a production-grade text-to-speech and voice conversion system with a Gradio-based WebUI and FastAPI REST API. It supports zero-shot voice cloning from a 5-second reference audio and few-shot fine-tuning with 1 minute of data. The system integrates multiple model versions (v1–v4, v2Pro, v2ProPlus) with autoregressive (GPT-style) and non-autoregressive (SoVITS/CFM) components, plus a BigVGAN vocoder. It includes a full pipeline for dataset preparation (voice separation, ASR, text labeling), training (with DDP, LoRA, DPO), and inference (streaming, parallel, ONNX/TorchScript export). The codebase is heavily modular with reusable text frontends for Chinese, Japanese, Korean, Cantonese, and English, as well as audio processing tools (UVR5, BS-Roformer, AP-BWE). Despite its breadth, the code exhibits significant technical debt: version sprawl, hardcoded paths, global state, and experimental hacks. It is actively maintained with frequent bug fixes and feature additions.
This is a Python application and library for singing voice conversion and real-time voice changing, forked from so-vits-svc and rebuilt around PyTorch, PyTorch Lightning, and a Click-based CLI. The actual code provides two user-facing entry points: the `svc` CLI with commands for inference, realtime microphone conversion, dataset preprocessing, training, clustering, and cleanup, and the `svcg` PySimpleGUI desktop application for interactive and realtime inference. Inference loads a HuBERT content encoder from Hugging Face, extracts pitch using CREPE, DIO, Harvest, or Parselmouth, then runs a VITS-style SynthesizerTrn with either HiFi-GAN or MS/MB-iSTFT decoders conditioned on speaker embeddings. Despite fastapi being listed as a dependency, no HTTP API server exists in the source; the project is a desktop/CLI tool, not a web service.
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.
P-HAR is a video analysis application that performs human action recognition specifically tailored for adult content. It processes input videos through three complementary modalities: visual frames (using TimeSformer), human pose sequences (using PoseC3D), and audio features (using a ResNet-based model). The system extracts features from each modality, runs inference through specialized deep learning models, and fuses the results using a weighted late fusion approach that handles heterogeneous output spaces. The architecture follows a modular pipeline: video input undergoes frame extraction and preprocessing, then each modality is processed independently through its respective model pipeline. The RGB stream processes spatiotemporal visual features, the skeleton stream first performs human detection and pose estimation before action recognition, and the audio stream extracts loudness-normalized spectral features. Results from all three streams are aligned to a common label space and combined using weighted averaging to produce final action predictions. Output can be generated as an annotated video with overlayed action labels and confidence scores, or as a JSON file containing temporal predictions for further processing. Key entry points include the multimodal demo script for end-to-end video processing, utility scripts for dataset preparation and model evaluation, and specialized tools for audio filtering and data pipeline management. The application relies on the MMAction2 framework ecosystem (including MMDetection and MMPose) for core computer vision capabilities, supplemented by standard Python libraries for media processing and data handling.
This repository is a comprehensive PyTorch library for person re-identification (re-ID), providing a full pipeline for training, evaluating, and deploying deep learning models. It includes a modular architecture with data managers (ImageDataManager, VideoDataManager), a large model zoo (OSNet, ResNet, DenseNet, HACNN, etc.), training engines (softmax, triplet, with video support), loss functions (cross-entropy with label smoothing, triplet with hard mining), metrics (CMC, mAP with Cython acceleration), and utilities (feature extraction, model export to ONNX/OpenVINO/TFLite, re-ranking). The codebase is well-organized into subpackages (torchreid.models, torchreid.data, torchreid.engine, etc.) and includes research projects (attribute recognition, deep mutual learning, neural architecture search). While the library is feature-rich and demonstrates strong engineering for its domain, it has not been actively maintained since mid-2022, relies on outdated dependencies (Python 3.6, torch 1.10), and contains deprecated API usage. It remains a valuable reference for re-ID practitioners but requires updates for modern environments.
This repository is a curated, comprehensive list of academic papers on the application of deep learning to protein design. It is not a software application or a data pipeline; rather, it is a living bibliography organized by research area (e.g., inverse folding, diffusion-based design, language models, antibody design). The README.md file contains hundreds of paper entries with links to publications, code repositories, and supplementary materials, updated frequently (last update shown as 2026.08.02). There is no executable code, no datasets, and no computational workflows. The value lies in its role as a reference index for researchers and practitioners tracking the rapidly evolving field of AI-driven protein design.
This repository is a comprehensive collection of educational tutorials that implement machine learning algorithms and applications entirely from scratch using only NumPy. It covers a vast range of topics including core ML algorithms (linear regression, SVM, K-means, PCA, etc.), neural networks (CNN, RNN, LSTM, GAN, transformer), computer vision (object detection, face recognition, OCR), natural language processing (sentiment analysis, chatbots, text summarization, BPE tokenizer), time series forecasting (ARIMA, LSTM, Prophet), recommendation systems, anomaly detection, and reinforcement learning. Each tutorial is a self-contained Python script that generates synthetic data with planted structure, trains a hand-coded model, and validates against naive baselines. The code is heavily commented and designed for teaching, not production. There are no real datasets, no external dependencies beyond NumPy, and no shared library—each file is independent, leading to significant code duplication across tutorials. The repository serves as an excellent learning resource for understanding the inner workings of ML algorithms, but it is not suitable for direct reuse in production systems without substantial refactoring.
This repository is a high-frequency trading (HFT) research and development framework, primarily written in Java with a significant Python layer for reinforcement learning and data analysis. The actual system provides a modular architecture for backtesting and live execution of algorithmic trading strategies across multiple exchanges (Binance, Interactive Brokers, Kraken, MetaTrader). It supports market making algorithms (Avellaneda-Stoikov, ConstantSpread), factor investing, and a wide range of execution algorithms (TWAP, VWAP, Implementation Shortfall). Reinforcement learning integration is a key feature, with Gymnasium environments communicating via ZeroMQ to Java-based RL agents. The data pipeline ingests tick-level depth and trade data from Parquet/CSV files or live streams, generates OHLCV candles, and feeds into both traditional backtesting and RL training loops. While the framework is functionally rich and demonstrates advanced patterns (Disruptor ring buffers, object pools, time-series utilities), the codebase suffers from maintenance drift: many third-party libraries are vendored or outdated, hardcoded paths are scattered, and several modules contain commented-out or incomplete code. The project is a hybrid of a production-like trading engine and research code, with the dominant character being an application framework for algorithmic trading research.
This repository is a desktop application for extracting subtitles from video files using OCR and subtitle detection. It integrates PaddleOCR inference models for text recognition, uses a separate binary tool (VideoSubFinder) for detecting subtitle regions, and employs the Sushi library for subtitle synchronization. The application is written in Python with a PyQt-based GUI (gui.py) and provides a modular backend with separate modules for OCR, subtitle detection, concurrent task management, and hardware acceleration. The project includes pre-compiled binaries for Windows, Linux, and macOS, as well as CI/CD workflows for building Windows executables. While the overall architecture is functional and suitable for its purpose, the code's internal quality and reusability cannot be fully assessed without inspecting source contents. The repository is actively maintained and has a large user base, but it is primarily a monolithic application rather than a reusable library.
OpenCV Zoo is a curated collection of pre-trained computer vision models optimized for OpenCV's DNN module, accompanied by inference demo scripts (Python and C++), benchmarking harness, evaluation tools, and quantization utilities. The repository serves as a practical resource for deploying models on a wide range of hardware (x86, ARM, RISC-V, NPUs) by providing ready-to-run code for tasks such as face detection/recognition, object detection, segmentation, text detection/recognition, pose estimation, and more. While primarily an application-oriented model zoo, it also includes research-grade evaluation metrics (e.g., LFW, WIDERFace) and quantization workflows, giving it a hybrid character that bridges model deployment and performance characterization. The benchmarking framework and quantization tools are the most architecturally coherent parts; model-specific demos are utilitarian but tightly coupled to their respective ONNX graphs.
This repository implements BTD, a deep neural network (DNN) executable decompiler for x86 binaries. It recovers model specifications (operator types, topology, dimensions, parameters) from DNN executables compiled by TVM, Glow, and NNFusion frameworks. The system uses dynamic binary instrumentation via Intel Pin to collect execution traces, applies symbolic execution and taint analysis to recover tensor shapes, extracts parameters from memory dumps, and rebuilds models in PyTorch for correctness verification. The architecture consists of interconnected Python scripts and Pin tools organized around a three-phase decompilation pipeline: trace collection and filtering, shape recovery via symbolic execution, and parameter extraction. Key entry points include evaluation shell scripts (decompile_eval.sh, op_infer_eval.sh) and model-specific decompile/rebuild scripts in the evaluation/ directory. The system relies on external dependencies including Intel Pin 3.14, IDA Pro 7.5 (optional), and specific compiler versions (TVM v0.7-v0.9, Glow 2020-2022, NNFusion).
This repository is a curated collection of baseline solutions for data science competitions, primarily from Chinese platforms (科大讯飞 AI开发者大赛, Tianchi, DataFountain, AIWIN, etc.) and some international ones (Kaggle). It contains hundreds of Jupyter notebooks and Python scripts covering a wide range of tasks: structured data classification/regression (LightGBM, XGBoost), computer vision (ResNet, EfficientNet, YOLO, CRNN), natural language processing (BERT, TF-IDF, Qwen), time series forecasting, and multimodal challenges. Each baseline is self-contained, providing a quick-start pipeline from data loading to submission generation. The repository serves as a practical learning resource for competition participants, demonstrating common feature engineering techniques, model training loops, and ensemble strategies. However, the code quality is uneven: many notebooks are exploratory with hardcoded paths, outdated library versions, and minimal error handling. The repo lacks centralized dependency management, environment definitions, or modular reusable libraries, making reproducibility low without manual adaptation. Despite these limitations, it offers a valuable catalog of patterns and templates that can be adapted for new competitions.
This is an implementation of SV2TTS (Transfer Learning from Speaker Verification to Multispeaker Text-To-Speech Synthesis) with a real-time vocoder, structured as a three-stage deep learning pipeline: speaker encoder, Tacotron-based synthesizer, and WaveRNN vocoder. The system clones a voice from a few seconds of reference audio and then synthesizes arbitrary text in that voice. The architecture is a monolithic Python application with CLI and PyQt5 GUI entry points. The encoder module implements a GE2E-loss LSTM speaker encoder trained on VoxCeleb/LibriSpeech. The synthesizer module is a Tacotron variant conditioned on speaker embeddings. The vocoder module is a modified WaveRNN (fatchord version) that generates audio in real-time. All three stages have independent training scripts and inference interfaces. The codebase was a landmark open-source voice cloning project but is now significantly outdated. It pins Python 3.9, PyTorch 1.10, and uses deprecated APIs (scipy.ndimage.morphology.binary_dilation, visdom, webrtcvad). The synthesizer uses a pure-Python instead of CUDA-optimized attention mechanism. The deepmind_version.py vocoder references non-existent utils modules, suggesting incomplete refactoring. The CI pipeline only runs import smoke tests.
This repository hosts the Hugging Face Deep Reinforcement Learning Course (v2.0), a free, open-source educational curriculum covering RL from fundamentals (Q-Learning, Policy Gradients) to advanced topics (PPO, A2C, Multi-Agent RL, Curiosity-Driven RL). It is primarily a collection of theoretical lessons (MDX files) and hands-on Jupyter notebooks designed to run on Google Colab. The notebooks train agents using libraries like Stable-Baselines3, CleanRL, ML-Agents, and Sample Factory, and push trained models to the Hugging Face Hub with evaluation videos and leaderboard comparison. While not a production application or data pipeline, the repo contains reusable training loops, evaluation helpers, and Hub packaging functions that can be extracted for other RL projects. The course is in low-maintenance mode, with some broken features (Unit 7 AI vs AI) and dependency drift (gym vs gymnasium), but the core content remains functional and well-structured.