This is the TensorFlow Model Garden, a large monorepo of model implementations, training loops, and research code. The dominant character is an application/framework: it provides official TF2 model code under `official/`, a custom training library under `orbit/`, and a large body of research code under `research/` and `community/`. The codebase is not a single deployable service but a collection of training/eval/export scripts, model factories, config systems, and data pipelines. It uses Gin configs, dataclass-based configs, and a registry pattern to compose models, tasks, and data loaders. Tests exist across the repo, and CI workflows are present. The repository is hybrid in that it contains research-oriented experiments and data-processing code, but the core is a software framework for building and training TensorFlow models.
OpenUBA is a full-stack User and Entity Behavior Analytics (UEBA) platform for security anomaly detection, investigation, and response. It provides a complete lifecycle for ML models (install, train, infer, version, share) via a pluggable registry supporting OpenUBA Hub, GitHub, HuggingFace, and local filesystem. The platform includes a rule engine with a visual DAG-based builder (ReactFlow), case management, real-time dashboards, multi-backend visualization (matplotlib, plotly, bokeh, etc.), and an LLM-powered assistant. The backend is built on FastAPI with PostgreSQL, SQLAlchemy, JWT/RBAC authentication, and optional Spark/Elasticsearch integrations. The frontend uses Next.js 14 (App Router), Apollo Client (GraphQL), shadcn/ui, and Recharts. A Python SDK enables programmatic access to all features. The system runs on Kubernetes with a Kopf operator managing custom resources (UBATraining, UBAInference, UBAWorkspace, UBAPipeline) for containerized model execution in isolated Docker images per ML framework (sklearn, PyTorch, TensorFlow, NetworkX). While primarily an application, it includes research-oriented components like experiment tracking, feature store, and Jupyter notebook workspaces, making it a hybrid tool for both security operations and data science workflows.
This repository is a massive, multi-disciplinary research codebase from Google Research, primarily focused on machine learning, optimization, and computer science experiments. While it contains a few application-like components (e.g., a Next.js frontend for model exploration, a Rust-based 3D splatting renderer), the dominant character is data_research, hosting thousands of independent experimental projects. The codebase serves as a central hub for publishing reproducible research in domains including Reinforcement Learning, Computer Vision (NeRF, 3D), NLP (Transformers, LLMs), and Privacy. It relies heavily on shell scripts for environment setup and experiment orchestration, with a mix of Python, C++, Rust, and Java implementations. The infrastructure is robust for research (e.g., `scann` for search, `lila` for experiment management) but exhibits significant fragmentation and technical debt due to the rapid pace of research and mixed framework usage.
This repository is a container build system and runtime for NVIDIA Jetson edge AI devices. It provides a modular, composable framework for building Docker images pre-configured with AI/ML libraries (LLMs, VLMs, robotics, speech, computer vision) optimized for Jetson's ARM64 + CUDA architecture. The system includes a CLI (`jetson-containers`), dependency resolution, multi-stage Docker builds, automated testing, and CI/CD workflow generation. While primarily a build tool, it also ships hundreds of ready-to-use container definitions for popular frameworks like PyTorch, TensorFlow, vLLM, ComfyUI, ROS 2, and Home Assistant. The repository has a hybrid character: the core is an application build system, but many package definitions are research-oriented (e.g., attention kernels, diffusion models, physical AI), reflecting its dual role as both a production deployment tool and an experimentation platform for edge AI.
Photonix is a self-hosted, full-stack photo management application with AI-powered classification and search. The backend is a Django monolith exposing a GraphQL API, with background workers for importing, thumbnail generation, raw processing, and ML classification (color, objects, faces, location, style, events). The frontend is a React 19 single-page app built with TanStack Router, Apollo Client, Zustand state management, and a dark-themed shadcn/ui component library. The system supports multi-user libraries, invitations, map view, albums, and fine-grained search with facets. The architecture relies on a PostgreSQL database, Redis for task coordination and locks, and supervisor to manage numerous background processes. While the project shows solid engineering and a modern tech stack, it carries some technical debt from vendored ML models, TensorFlow 1.x compatibility, and hardcoded download URLs, and is explicitly not yet feature-complete.
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.
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.
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 collection of TensorFlow Lite example applications for on-device machine learning, covering tasks such as image classification, object detection, pose estimation, audio classification, BERT question answering, gesture recognition, and more. It provides complete Android (Kotlin/Java), iOS (Swift), Raspberry Pi, and web implementations, each demonstrating best practices for camera integration, hardware delegate selection, and real-time inference. Additionally, the repository includes the TensorFlow Lite Model Maker library, which offers high-level APIs for training and exporting custom TFLite models from user data, along with research/educational models (DenseNet, pix2pix, NMT). While the codebase shows some duplication across platforms and occasional legacy API usage, it remains a valuable reference for developers building edge ML applications.
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.
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 is a large model zoo (500+ models) focused on converting and quantizing pre-trained computer vision models for edge deployment across multiple frameworks (TFLite, ONNX, OpenVINO, CoreML, TensorRT). It provides hundreds of download scripts for pre-converted model files, conversion pipelines (PyTorch/ TensorFlow to ONNX/TFLite), and a modest set of inference demo scripts for real-time video processing. The repo is primarily a research/engineering resource for edge AI practitioners, not a software application. It exhibits heavy duplication across model directories, relies on an external S3 bucket for model distribution, and uses older framework versions (TensorFlow 1.x/2.x, ONNX opset 11-13). Despite these maintenance concerns, the systematic conversion workflow and post-processing ONNX subgraph generators (e.g., NMS, box decoding) represent reusable patterns for anyone building end-to-end inference pipelines. The repo is hybrid in nature: while classified as data_research due to its focus on pre-trained model artifacts and lack of original training code, it also contains application-like demo code and CLI entry points.
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 provides a comprehensive research codebase for AI-driven character animation, spanning multiple SIGGRAPH publications from 2017 to 2024. It includes deep learning model training scripts (TensorFlow for PFNN, MANN, NSM; PyTorch for GNN, PAE, Codebook Matching) and corresponding Unity integration for real-time inference and visualization. The codebase ingests motion capture data (BVH, FBX, TRC), processes it through a Unity-based data pipeline (MotionData, Frame, Modules), trains phase-functioned or mode-adaptive networks, and exports trained weights for runtime use. The repository is hybrid: primarily a research project with both data pipeline (motion capture processing, feature extraction) and application (Unity demos, IK, visualization tools) components. It is not a standalone library but a reference implementation for academic publications, making it valuable for researchers and developers working on character animation, deep learning for motion, and real-time animation systems.
Petastorm is a library for loading Apache Parquet datasets into machine learning training frameworks, primarily TensorFlow and PyTorch. It provides a reader API that supports parallel I/O, row-group shuffling, predicate filtering, and on-the-fly transformations. The library also includes a Spark Dataset Converter to materialize Spark DataFrames as cached Parquet for training. Architecture: modular with worker pools (process/thread), filesystem abstraction (local, HDFS, S3, GCS), schema system (Unischema with codecs), and shuffling buffers. It features CLI tools for benchmarking, metadata generation, and dataset copying. The codebase demonstrates strong engineering practices with clear separation of concerns, but shows signs of aging: reliance on TensorFlow 1.x, Python 2 compatibility, and pinned dependencies that may cause drift. The project has a large test suite with legacy dataset fixtures for backward compatibility, but maintenance has slowed significantly with the last release (v0.13.1) and minimal recent commits.
This repository is the companion code for the first edition of 'Hands-on Machine Learning with Scikit-Learn and TensorFlow' (2017). It contains a collection of Jupyter notebooks teaching fundamental and advanced machine learning concepts, covering classification, SVMs, decision trees, ensemble methods, dimensionality reduction, and deep learning with TensorFlow 1.x (including CNNs, RNNs, autoencoders, and reinforcement learning). The code is educational, with step-by-step implementations, inline explanations, and exercise solutions. It is not a production application but a self-contained learning environment, supplemented with datasets (California housing, OECD life satisfaction, MNIST) and a Docker setup for reproducible execution. Significant technical drift exists: TensorFlow 1.x APIs, deprecated scikit-learn imports, and Python 2/3 compatibility shims make the notebooks incompatible with modern environments without substantial rewriting. The README explicitly directs users to the second edition repository for up-to-date code.
This repository implements an audio-driven facial animation pipeline that maps speech audio to blendshape weights for driving a digital human in Unreal Engine. The core is a deep learning model (Audio2Face) trained on paired audio (WAV) and blendshape weight data (exported from Maya). The training pipeline includes: (1) Linear Predictive Coding (LPC) feature extraction from audio via a C++ DLL, (2) data concatenation and selection of variable blendshape indices, (3) training a custom Keras model with a three-part loss (prediction, motion, emotion regularization), and (4) inference via TensorFlow Lite. A test application demonstrates real-time inference with microphone input, speech recognition (via AISpeech API), and UDP communication to UE4. The repository is primarily a research codebase with a demo application, but lacks dependency pinning, environment definitions, and contains hardcoded paths, making reproduction difficult. The model architecture and loss function are well-structured and potentially reusable.
This repository is a research artifact from the NL2Bash project (LREC 2018), providing a dataset and neural semantic parser for translating natural language descriptions into Bash one-liners. The core contributions include a parallel corpus of ~10k NL–Bash pairs, TensorFlow-based sequence-to-sequence models with attention and copy mechanisms, a custom Bash command parser (bashlint) that normalizes commands using a grammar extracted from man pages, and evaluation tools including tree edit distance and manual judgment pipelines. The codebase is primarily a research prototype with pre-trained model checkpoints, data preprocessing scripts, and evaluation files. While the dataset and parser are valuable, the dependency on TensorFlow 1.x, JavaCC, and Python 2/3 compatibility indicates significant drift. The repository is no longer actively maintained, but the documented methodology and reusable components (e.g., tree edit distance, statistical spell checker) remain relevant for similar NL-to-code tasks.
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.