This repository is a curated awesome-list of research papers, projects, datasets, and industry demos related to digital humans: 3D avatar generation and animation, clothed human reconstruction, head avatars, human motion generation, virtual try-on, cloth simulation, and related topics. It contains only a README.md plus LICENSE; there is no application code, no executable pipeline, no tests, no CI, and no dependency manifests. Despite the data_research classification, it is best understood as a manually maintained literature index rather than a data pipeline or software project.
This repository is a comprehensive collection of AI model demos and sample applications for Sophgo's Sophon TPU hardware (BM1684X, BM1688, CV186X). It provides both Python and C++ implementations for running inference on a wide range of models including object detection (YOLO variants, CenterNet), segmentation (SAM, YOLACT), OCR (PP-OCR, LPRNet), large language models (Qwen, ChatGLM, MiniCPM), speech recognition (Whisper, WeNet), text-to-speech (ChatTTS, VITS), and multi-modal models (CLIP, BLIP, GroundingDINO). The repository also includes full application demos such as a document QA chatbot (ChatDoc), an audio assistant pipeline (ASR+LLM+TTS), multi-channel video processing with Qt GUIs, and OpenAI-compatible API servers. The primary architecture is a set of independent, self-contained demos, each with its own model compilation scripts (using TPU-MLIR), inference code, and evaluation tools. While the codebase is functional and covers a broad spectrum of AI models, it suffers from significant code duplication across samples, hardcoded paths, and some outdated dependency versions, making it more of a demo showcase than a production-ready library.
This repository is a mobile SDK for real-time interactive AI avatars, primarily targeting Android and iOS platforms. It provides on-device inference for speech recognition (via WeNet) and face/body segmentation (via ncnn-based U-Net models), enabling low-latency lip-sync and avatar animation driven by audio input. The SDK is structured as a C++ core with platform-specific wrappers (Java for Android, Objective-C for iOS), and includes bundled third-party libraries (ncnn, OpenCV, FFmpeg, ONNX Runtime) for computer vision, audio processing, and neural network inference. In production, the system ingests 16kHz PCM audio from a microphone, extracts MFCC features, runs streaming speech recognition, and simultaneously processes the audio through a U-Net model to generate facial animation frames. These frames are rendered using OpenGL ES (Android) or Metal (iOS) with alpha blending for compositing onto a background. The SDK also includes model download, encryption (AES-128-CBC), and resource management utilities. The architecture is monolithic: all core logic lives in a single C++ module (duix-sdk), with platform-specific integration code in the app directories. The demo app in Android provides a fully functional test harness. While the SDK is feature-complete and demonstrates significant engineering effort in mobile AI inference, the codebase exhibits several quality issues: duplicated third-party headers across architectures, hardcoded encryption keys, outdated library versions (OpenCV 4.6.0, ncnn 2022/2023), and minimal inline documentation. The high star count and fork activity suggest a strong community, but the code itself is functional rather than exemplar. The most reusable components are the reference-counted memory allocator (dh_mem.h) and the AES stream decryption wrapper (gaes_stream.h), which can be extracted for general-purpose use.
This repository is an educational tutorial implementation of a stereo visual SLAM (Simultaneous Localization and Mapping) system, based on the classic feature-point method (ORB/GFTT) with optical flow tracking, PnP pose estimation, and local bundle adjustment using g2o. It is structured as a modular C++ library (libmyslam.so) with components for frontend, backend, map management, camera model, dataset reading, and Pangolin-based 3D visualization. The primary entry point is a CLI application that processes KITTI stereo sequences to estimate camera trajectory and sparse 3D map points. While the code demonstrates solid software engineering practices such as threading, singletons, and factory methods, it is not production-ready: it lacks loop closure, map persistence, and comprehensive testing. The repository serves as a hands-on companion to the 'Visual SLAM: From Theory to Practice' textbook, with documentation and chapter-wise code examples. External dependencies include OpenCV, Eigen, Sophus, g2o, Pangolin, and Glog, with version-specific requirements that may cause compatibility issues on modern systems.
This repository contains educational labs for MIT's Introduction to Deep Learning course (6.S191). It consists of Jupyter notebooks covering deep learning fundamentals (Lab1: music generation with RNNs), computer vision (Lab2: MNIST classification and facial detection with VAEs), and LLM fine-tuning (Lab3: style adaptation using LoRA). The repository also includes extra labs for reinforcement learning and uncertainty quantification. While structured as educational material, the labs involve substantive data processing, model training, and evaluation pipelines. The mitdeeplearning package provides reusable utilities for training visualization and data handling. The code assumes execution in Google Colab with GPU access and relies on external APIs (Comet ML, OpenRouter) and datasets hosted on third-party services (Dropbox).
This repository is the public release of the SLAM Handbook, a comprehensive book on Simultaneous Localization and Mapping (SLAM) to be published by Cambridge University Press. It contains the book manuscript (main.pdf), LaTeX style files for acronyms and bibliography strings, and a bug report template. The repository is primarily a document project rather than a software application, but the LaTeX infrastructure (SH_acronyms.sty and SH_string.bib) serves as a reusable library for typesetting SLAM-related documents. The book covers foundations, practical implementations, and spatial AI, with contributions from numerous experts. The repository is actively maintained with incremental releases and community feedback mechanisms via issues and discussions.
This is the Qualcomm Innovators Development Kit (QIDK), a collection of Android sample applications and tools demonstrating on-device AI inference using the Qualcomm Neural Processing SDK (SNPE) and Qualcomm Neural Network (QNN) runtime. The repository covers computer vision (object detection, pose estimation, super-resolution, image enhancement), NLP (sentiment analysis, question answering, automatic speech recognition), and generative AI (LLM chat, speech-to-image, ASR-LLM-TTS pipeline). Each solution is a standalone Android app with native C++ JNI code that integrates the SNPE/QNN SDK for accelerated inference on Snapdragon platforms. The repository also includes tools like `pysnpe_utils` (Python library for model conversion and execution), `snpe-helper` (Python wrapper for SNPE runtime), and low-level Hexagon compute examples (QHCI/HVX). While the codebase is functional and covers a wide range of use cases, it suffers from significant code duplication across solutions, hardcoded paths, and version coupling to specific SDK releases. The architecture is a collection of loosely coupled sample apps rather than a unified framework, limiting cross-project reuse. The commit history shows ongoing maintenance, but the last commit date appears anomalous (2026), and several files reference future copyright years, suggesting pre-release content.
MetaSeg is a Python library that packages Facebook's Segment Anything Model (SAM) into an easy-to-use interface for automatic and manual image/video segmentation. It provides high-level predictors (SegAutoMaskPredictor, SegManualMaskPredictor) that handle model loading, inference, and output visualization. The library integrates with SAHI for sliced inference and FalAI for cloud GPU execution, and includes a Gradio web application. The codebase is primarily a thin orchestration layer over the official SAM implementation, with additional utility functions for data loading, video processing, and model download. It is designed for developers who want to quickly apply SAM without deep model internals.
This repository is a comprehensive AI inference and application platform built primarily on Java (Spring Boot) and Vue.js. It provides a suite of SDKs for computer vision (face recognition, OCR, segmentation), NLP (text embedding, translation), and AIGC (Stable Diffusion, ControlNet). The architecture is modular, separating inference logic (SDKs) from application logic (Web Apps, Desktop Apps, API Platform). It utilizes Deep Java Library (DJL) for model inference, integrating PyTorch and ONNX Runtime backends. The system supports multimodal search (Face, Image, Code, Text) using vector databases like Milvus. Hybridity: While it contains AI research components (models, inference), the codebase is structured as a production-ready software platform with web interfaces, APIs, and desktop wrappers, rather than a research notebook collection. It functions as a monorepo containing multiple distinct Spring Boot applications and Vue.js frontends, each serving a specific AI task (e.g., face_search, image_search, aigc_image_gen).
This repository is a curated resource list for deep learning-based face restoration algorithms, organized as a survey. It contains no executable code, data processing scripts, or model implementations. Instead, it provides structured tables categorizing research papers by year, publication, title, links, and architecture across tasks like blind face restoration, super-resolution, deblurring, denoising, and artifact removal. The README.md serves as the primary documentation, supplemented by illustrative GIFs in the figures directory. While valuable as a reference, it lacks any reusable components or reproducible research elements since it solely aggregates external links without original code, data, or experiments.
This repository is primarily an extensive educational compendium covering mathematics, computer science, and artificial intelligence from first principles to state-of-the-art topics. It contains over 100 markdown files organized into 20 chapters, each with detailed explanations, diagrams, and interactive coding tasks (primarily in Python/JAX). The repo also includes auxiliary tooling: a MkDocs-based documentation site with MathJax and a Pyodide in-browser Python runner that includes a JAX compatibility shim, and a TypeScript MCP (Model Context Protocol) server that provides programmatic access to the compendium content for AI assistants. While the vast majority of the repository is educational content rather than runnable software, the MCP server and interactive runner are functional application components. The compendium is well-structured and current, but the code examples are pedagogical (simplified, not production-ready) and the JAX shim is a fragile polyfill. The project is not a data research pipeline—it contains no datasets, experiment logs, or trained models.
This repository implements a wide range of image processing algorithms in C++ (with some Python components for license plate recognition). It provides functionalities including contrast enhancement, color space conversion, filtering (median, Gaussian, bilateral), feature detection (edges, corners), image interpolation, haze removal, and artistic effects similar to Photoshop. The architecture is modular with algorithms grouped by category in separate directories. Many files include main() functions allowing them to be compiled and run as standalone demonstrations. The primary external dependency is OpenCV, with some files using OpenMP for parallel processing and Intel intrinsics for AVX optimizations. The license plate recognition system integrates C++ preprocessing with TensorFlow/Keras models in Python for character recognition.
This repository provides a PyTorch implementation of Vision Mamba, a visual representation learning model based on bidirectional state space models (SSM). The core code in vision_mamba/model.py defines two classes: VisionEncoderMambaBlock, which applies a bidirectional SSM with convolutional processing, and Vim, which assembles a full vision classifier using patch embedding, a stack of encoder blocks, and an output head. The implementation relies heavily on the external `zetascale` library for the SSM primitive and `einops` for tensor rearrangements. Several issues indicate a work-in-progress state: the forward pass contains active print statements, a class token is defined but never used in the forward path, the convolutional layers use a kernel size of 1 (which may be incorrect for sequence modeling), and there are no unit tests or validation data. The abundant GitHub Actions workflows suggest an intent for continuous integration, but they reference non-existent test directories, so they would not pass. Overall, the repository is a functional but unpolished research prototype suitable for experimentation, but not production use or reuse as a library.
The FairFace repository serves as a documentation hub for the FairFace dataset, providing links to download facial images annotated with race, gender, and age attributes for bias measurement and mitigation in computer vision. It contains no source code, only a README.md detailing dataset characteristics, preprocessing methods (using dlib's get_face_chip with specific padding), and external links to download the data, labels, and pretrained models hosted on Google Drive. The repository functions purely as a reference point for accessing the dataset rather than offering any computational tools or reusable assets. As a data research artifact, it lacks essential components for reproducibility: no data loading scripts, preprocessing code, evaluation notebooks, or dependency management. Users must manually implement workflows to utilize the dataset. While the README provides clear attribution and download instructions, the absence of bundled data, environment specifications, or code limits its utility as a self-contained research resource. The dataset itself addresses bias in facial analysis systems, but this repository only facilitates access rather than enabling analysis. Maintenance appears stale based on the anomalous future-dated last commit (2026-01-04), indicating no recent activity. Technical drift is minimal due to the absence of code or dependencies, though external download links may risk obsolescence. The repository's value lies solely in its role as a citation pointer and access guide for the FairFace dataset, not in providing reusable data engineering components.
This repository is a curated 'awesome list' for Federated Learning (FL) research, maintained as a Jekyll static site. It aggregates hundreds of linked GitHub repositories and DBLP search strategies. The core data asset is a machine-generated go.mod file that pseudo-pins the linked repositories as Go dependencies, produced by the add_dependent.py script which extracts GitHub URLs from README.md, queries the GitHub API for commit hashes, and writes a go.mod. However, this is not a functional Go module; it is a novelty lockfile. The dblp-search-keywords.md document provides a meticulous analysis of DBLP search syntax to discover FL papers without the 'federate' keyword. The repository has significant hybrid character: while it is primarily a content aggregation site (application-adjacent), its technical substance lies in the data exploration and search strategy documentation (research-oriented). The actual code is minimal and tightly coupled to the repository's specific structure, limiting reusability. The add_dependent.py script is a one-time scraper with hardcoded rate limiting and token placeholder, not a general-purpose tool.
This is a Torch7 implementation of the seminal neural style transfer algorithm (Gatys et al., 2015). It provides a command-line interface for artistic style transfer: given a content image and one or more style images, it optimizes a target image to simultaneously match the content of the content image and the statistical style (Gram matrix features) of the style image, using a pre-trained VGG-19 CNN. The single-file script (`neural_style.lua`) defines custom nn modules for content loss, style loss, Gram matrix computation, and total variation regularization. It supports L-BFGS and Adam optimizers, multiple backends (nn, cuDNN, clnn), multi-GPU splitting, and various tunable parameters (layer selection, style scale, weight blending). The code is well-structured for its era and demonstrates solid understanding of Torch7's autograd mechanics, but it is a monolithic research prototype with no test suite and heavy dependency on now-deprecated libraries (Torch7, loadcaffe, cudnn.torch). Its architecture is not modular enough for easy extraction as a library. The repository is historically significant but effectively obsolete for practical use in modern deep learning ecosystems.
DART (Detect Anything in Real Time) is a training-free framework that converts SAM3 into a real-time multi-class open-vocabulary detector. In practice, the codebase is an inference-optimization and deployment framework: it exports SAM3 backbone components to ONNX/TensorRT, applies FP16/INT8 quantization, builds optimized TRT engines, and runs pipelined video inference with CUDA graphs and torch.compile. It also includes an LLM-driven interactive agent (Qwen via OpenAI-compatible API) that performs iterative segmentation through tool calls (segment_phrase, examine_each_mask, select_masks_and_return), plus video dataset handling, grounding/mask export utilities, and COCO-style evaluation scripts. The repository is a hybrid: fundamentally an application/framework for real-time detection, it carries strong research-code characteristics — calibration caches (calib/*.json), ad-hoc experiment scripts with hardcoded checkpoints (sam3.pt, backbone.onnx), and iterative debugging comments ('Previous test showed...'). The architecture centers on ONNX export of SAM3 blocks (EfficientViT backbone, text encoder, prompt encoder, mask predictor, pixel decoder), TRT engine building, and a quantization layer (dartf/quant/) with experimental plugins tightly coupled to specific ONNX graph patterns. A media production pipeline (dartf/media/) builds explainer videos with automated slide rendering and music mixing. The codebase shows signs of being an experimental workspace rather than a maintained library: hardcoded paths in evaluation configs, version-sensitive TensorRT API usage, a fragile ONNX export pipeline depending on onnxsim subprocess calls, and potential drift between ONNX-exported blocks and real backbone behavior. The 'training-free' claim is partially contradicted by the presence of distillation training code, and the package name dart-detect vs module sam3 mismatch may cause import confusion. Despite these issues, several well-isolated components — an abstract prediction-file evaluator, a TensorRT layer analysis script, and an LLM agent client — could be extracted for reuse in other vision or agent projects.
This repository implements a deep learning image inpainting model for watermark removal, based on the Contextual Attention (CVPR 2018) and Gated Convolution (ICCV 2019) papers. It provides a CLI tool (main.py) that loads a pre-trained TensorFlow 1.x checkpoint, applies a user-supplied mask (defaulting to a specific watermark pattern like iStock), and outputs the inpainted image. The code includes the full model definition (inpaint_model.py), custom operations (inpaint_ops.py), preprocessing utilities, batch inference scripts, and a Dockerfile. The architecture is a two-stage generator with a spectral normalization discriminator, trained on datasets like CelebA-HQ and Places2. However, the repository is primarily designed for inference; training code is present but not the primary focus. The project is heavily dependent on TensorFlow 1.15, the neuralgym library, and deprecated tf.contrib APIs, making it incompatible with modern TensorFlow 2.x without significant refactoring. The codebase is well-structured academically but not production-ready, with no tests and minimal documentation beyond the README.
This repository is a deprecated ONNX Model Zoo containing thousands of pre-trained models (mostly computer vision, some NLP and generative AI) exported to the ONNX format from PyTorch (timm, torchvision) and other frameworks. It also contains turnkeyml benchmark artifacts (turnkey_stats.yaml) that record export success, model metadata, ONNX operator counts, and system environment for each model across opsets 16–18. The primary purpose was to provide a centralized collection of ready-to-use ONNX models for inference and to validate cross-version ONNX export compatibility. However, the repository is explicitly deprecated (LFS disabled July 2025) and users are redirected to Hugging Face. The codebase consists almost entirely of binary model files and YAML metadata; the only reusable software components are a few preprocessing scripts (e.g., imagenet_preprocess.py, face_preprocess.py) in the validated/ directories. There is no application logic, no API, no training pipelines—this is purely a model distribution and benchmark data repository. Reproducibility is low due to hardcoded paths, frozen env snapshots that are out of date, and reliance on external model sources whose weights may have changed.
The repository 'ml-road' is primarily a collection of educational resources for machine learning, deep learning, and agentic AI, including curated links to courses, books, and recent topics. It also contains two small demo applications: one for Chinese character recognition using a convolutional neural network with batch normalization (TensorFlow 1.x) and another for MNIST handwritten digit recognition using a softmax regression (TensorFlow 1.x). The applications are runnable as command-line tools but require specific data directory structures and are tightly coupled to global flags, limiting their reusability. The codebase shows signs of technical drift due to reliance on deprecated TensorFlow 1.x APIs.