GS-SDF is a research prototype from HKU-MARS that fuses LiDAR-augmented 3D Gaussian Splatting with a neural Signed Distance Field (SDF) for photorealistic rendering and high-fidelity surface reconstruction. The system ingests data from multiple sensor modalities (LiDAR, RGB-D, stereo) via a modular data parser hierarchy supporting Replica, FAST-LIVO2, KITTI, COLMAP, Oxford Spires, and other formats. It trains a neural SDF field with eikonal and curvature regularization, then initializes and refines 3D Gaussians guided by the SDF to produce view-dependent color and geometry. The pipeline includes real-time ROS visualization (RVIZ), offline mesh extraction via a custom CUDA marching cubes implementation, and evaluation scripts for image metrics (PSNR, SSIM, LPIPS) and structural metrics (Chamfer distance, F-score). The codebase is pre-release, with many TODOs and commented-out code, but exhibits strong modularity in its data loaders, loss functions, optimizer utilities, and coordinate transformations. While primarily a research codebase, it includes application-like features such as a ROS node with interactive keyboard commands and headless rendering modes.
This repository is a curated list of papers, datasets, and code repositories for multi-turn interactions with large language models, accompanied by a static website that serves as a companion to a survey paper published in Transactions on Machine Learning Research (TMLR) 2026. The website includes sections on tasks (instruction following and conversational engagement), improvement methods, open challenges, and a searchable benchmark explorer. The repository also includes a script for processing survey data from Excel files and the README, though this script is not required to run the website.
LLaVA-NeXT is a large multimodal model (LMM) research codebase that extends the LLaVA family to support single-image, multi-image, video, and interleaved tasks. It provides training pipelines for supervised fine-tuning (SFT), direct preference optimization (DPO), and reinforcement learning (PPO, GRPO) with custom vision encoders (CLIP, SigLIP, EVA-CLIP, MLCD) and modular projector/resampler components. The repository also includes a full RL training framework (EasyR1/verl) for large-scale GRPO training using Ray, FSDP, and vLLM, as well as evaluation scripts for video and interleaved benchmarks. While primarily a research codebase with extensive training configurations and experimental scripts, it also contains serving infrastructure (Gradio, SGLang, controller-worker) for deployment. The code is well-structured with reusable vision encoder wrappers, data protocols, and RL algorithm implementations, but suffers from hardcoded internal paths, multiple overlapping RL implementations, and legacy training pipelines that increase maintenance burden.
This repository is a comprehensive cybersecurity knowledge base focused on offensive security techniques, particularly binary exploitation, cryptography, reverse engineering, and CTF challenge writeups. It serves as an educational resource containing detailed tutorials, exploit development guides, and solution writeups for various platforms (HackTheBox, picoCTF, etc.). The content is organized by topic with markdown files explaining concepts ranging from basic stack overflows to advanced heap exploitation techniques like tcache poisoning and kernel attacks. While not containing runnable applications, it provides reusable exploit methodologies and code snippets that security practitioners can adapt for learning and CTF preparation.
This repository provides curated rule lists for the Shadowrocket iOS proxy application, categorizing tens of thousands of domains and IP ranges into DIRECT (no proxy), PROXY (route through proxy), and REJECT (block) sets. The rules are distributed as Shadowrocket modules that can be loaded independently or combined to implement white-list or black-list routing strategies. The data is aggregated from multiple public sources including dnsmasq-china-list, v2fly domain list, gfwlist, adblock lists, and custom additions for services like TikTok, OpenAI, Telegram, and Google Gemini. The repository also includes a minimal configuration example and factory files that allow users to customize rule sets by appending or excluding specific entries before automated builds. There is no application code; the entire output is data files consumed by Shadowrocket. The repository relies on external CI (not visible in the file tree) to regenerate the modules daily.
The OpenAI Cookbook is a sprawling collection of example code, notebooks, and guides for accomplishing tasks with the OpenAI API. It is not a single application but a repository of patterns. Its dominant character is data research and example code: it contains hundreds of Jupyter notebooks and Python scripts demonstrating embeddings, fine-tuning, RAG, agents, evals, MCP integrations, and vector database usage. The repo also includes full-stack demo applications (React/Next.js/Flask) for real-time translation, deployment management, and supply-chain copilots, making it a hybrid. There is no unified data lineage; instead, each example subsection defines its own data flow from API calls to local CSV/JSONL inputs. The quality is uneven: some eval harnesses and agent demos are well-structured, while many notebooks are scratchy and rely on inaccessible private data. The repository is maintained (last commit June 2026, CI workflows active) but shows medium technical drift, with some examples pinned to older library versions and many notebooks requiring manual environment setup.
The Open Cookie Database is a community-curated reference dataset cataloging HTTP cookies. The single source of truth is open-cookie-database.csv, which records each cookie's platform, category (Functional, Personalization, Analytics, Marketing, Security), cookie name/pattern, domain, description, retention period, data controller, GDPR/privacy policy URL, and a wildcard-match flag. The dataset is maintained through manual PR-based contributions following a documented research workflow, and it is consumed by downstream privacy tooling (notably the EU EDPB Website Auditing Tool, via a dedicated EDPB JSON export). A static HTML viewer renders the CSV client-side using PapaParse and DataTables for browsing and export. The data lineage is simple and fully automated: on every push touching the CSV, GitHub Actions runs validate.py (UUID format/uniqueness, category whitelist, duplicate detection), then regenerates two derived artifacts - open-cookie-database.json (records grouped by platform) via convert_csv_to_json.py, and open-cookie-database-edpb.json via convert_edpb.py, which maps the flat CSV onto the EDPB tool's nested knowledge-base JSON schema. The pipeline is deterministic, idempotent, and commits the regenerated JSON back to the repo when changed. There is no application runtime, API, or library; the three Python scripts and CI workflows are infrastructure that exists solely to keep the dataset valid and in sync across formats. Craftsmanship is functional but modest. The scripts show reasonable engineering discipline: CLI parameterization, graceful handling of missing/empty files, GitHub Actions error annotations, and non-zero exit codes on failure. The validation script encodes real data-quality rules. However, there are clear signs of aging: the HTML viewer references the retired StackPath Bootstrap CDN and contains a malformed protocol-relative script URL ('//http://...'); the main validation workflow still pins Node 16 (EOL) and uses checkout@v2; convert_edpb.py uses the deprecated datetime.utcnow(); and pandas is installed unpinned. These issues do not break the core CSV-to-JSON pipeline, but they make the supporting surface fragile. The repository is a data asset first and code second - the value lies in the curated cookie catalog and the governance around it, not in the software. It is a solid, genuinely useful open-data project with competent but unremarkable data engineering. An analyst can clone it and reproduce all derived JSON artifacts with just Python and pandas, since the dataset is bundled and the transforms are simple, explicit, and parameterized.
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 curated collection of management and engineering leadership resources, not a software application or data pipeline. It contains a personal README detailing the author's management philosophy, recommended readings on topics like AI, burnout, inclusivity, and technical leadership, a blog post on managing teams during COVID-19, documentation outlining expectations and meeting practices, and reusable templates for goal setting, artifacts, and one-on-one meetings. The content serves as a practical guide for managers to improve team dynamics, feedback processes, and leadership effectiveness. While it lacks executable code or data processing components, the resources are well-organized and actionable, offering value as a reference for engineering leadership practices.
This repository implements the research paper 'Image as an IMU: Estimating Camera Motion from a Single Motion-Blurred Image'. It provides code for training a neural network to estimate camera motion (rotation and translation) from a single motion-blurred image, using synthetic data generated from ScanNet++ and real-world fine-tuning data. The repository includes utilities for processing data from the StrayScanner iOS app, evaluating baselines (COLMAP, DROID-SLAM, MASt3R), and running real-time demos. The core contribution is a model that predicts optical flow, depth, and camera pose from a blurred image, then resolves motion direction ambiguity via photometric consistency checks.
This repository provides a collection of Amiibo binary files (.bin) for Animal Crossing: New Horizons characters, organized by series and special editions. It includes instructions for using the TagMo mobile application to write these files to NTAG215 NFC tags, enabling users to create functional Amiibo cards for personal use. The data is sourced from NFC-Bank and community contributions, with the repository serving as a static data distribution point for educational purposes. There are no data transformation scripts or processing tools included; the value lies in the curated collection of ready-to-use Amiibo dumps.
The code answers the research question of how to customize large text-to-image diffusion models with minimal data and minimal parameter updates, and it compares against DreamBooth and Textual Inversion. It includes reusable components for few-shot personalization, delta checkpoint handling, lightweight model compression, multi-concept weight composition, and CLIP/DINO evaluation, although the codebase shows research-level roughness: duplicated CompVis/diffusers paths, hardcoded paths, and several known bugs in conversion and composition utilities.
This repository is a curated list of tools and resources for security incident response and digital forensics (DFIR). It is organized into categories such as adversary emulation, evidence collection, log analysis tools, memory analysis tools, and more. Each entry includes a link and a brief description. The project includes GitHub Actions workflows to automatically check for broken URLs in the documentation and to lint the README for spelling errors, ensuring the list remains accurate and well-maintained. The primary value of this repository lies in its comprehensive collection of DFIR resources, which serves as a reference for security analysts and teams. The maintenance workflows demonstrate a commitment to data quality by proactively validating links and checking for spelling errors, which is essential for a resource list that relies on external URLs. While the repository does not contain complex data pipelines or analytical code, it effectively fulfills its purpose as a reference list through structured markdown and automated upkeep.
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 collection of tutorials, guides, and examples for integrating AI large language models with various services and platforms. It primarily serves as a resource base for the tech content creator 'ζζ―η¬η¬θΎ' (Tech Shrimp), containing video resource lists, step-by-step guides, and code snippets. The repository demonstrates practical patterns for AI integration including: RSS feed processing and summarization workflows (using n8n), AI-powered smart home assistants (integrating DingTalk with Home Assistant), and AI chatbots for messaging platforms (WeChat, DingTalk, Enterprise WeChat). While not a cohesive application itself, it contains reusable data pipeline patterns, particularly the n8n workflow for converting RSS feeds to AI-generated email newsletters, which exemplifies a practical ETL pattern using modern AI services.
This repository is an educational tutorial for single-cell sequencing analysis best practices using Python. It provides a structured series of Jupyter notebooks and documentation covering preprocessing, quality control, normalization, feature selection, and advanced topics like trajectory inference and multi-modal data analysis. The tutorial uses real-world example datasets (e.g., 10x Multiome) and emphasizes reproducible workflows with AnnData and MuData objects, leveraging libraries such as scanpy, omicverse, and scverse tools. While primarily educational, it demonstrates standard data analysis patterns that can be adapted for similar single-cell projects.
Show-o and Show-o2 are research repositories for unified multimodal understanding and generation. They implement transformer-based models (1.3B, 1.5B, 7B parameters) that can perform text-to-image generation, image/video captioning, visual question answering, inpainting/extrapolation, and mixed-modality generation (interleaved text and images). The codebase is organized around two major model versions: Show-o uses discrete tokens with MAGVITv2 VAE and Phi-1.5 LLM, while Show-o2 moves to continuous latent space with WanVAE (3D causal VAE) and Qwen2.5 LLM. Training follows a multi-stage pipeline (pretraining, instruction tuning) with novel techniques like flow matching (via a modular `transport` package), dual-path vision encoders (SigLIP + patch embedding), and omni-attention masks that combine causal and bidirectional attention for multimodal sequences. The repository includes distributed training configs (DeepSpeed, multi-node), evaluation scripts for GenEval and DPG-Bench, and comprehensive YAML configuration files. This is primarily a data_research codebase: it produces research artifacts (models, papers at ICLR 2025 and NeurIPS 2025) rather than a production application. The code exhibits good modularity for a research project, with reusable components like the transport module, omni-attention masks, mixed dataloader, and attention masking utilities. However, it suffers from typical research-code issues: hardcoded internal infrastructure paths, reliance on non-public data pipelines (e.g., internal packages for RefinedWeb), and some code duplication between Show-o and Show-o2. Reproducibility is moderateβdependencies are pinned and configs are detailed, but many datasets are large-scale web sources that require manual setup, and the training scripts assume specific hardware (multi-node A100 clusters). The project is actively maintained (commits in early 2026) with a roadmap for future work, including mixed-modal generation and video support.
This repository provides the official PyTorch implementation of TaDiCodec, a text-aware diffusion speech tokenizer accepted at NeurIPS 2025. The core contribution is a novel speech codec that achieves ultra-low bitrate (0.0875 kbps at 6.25 Hz) by combining a non-autoregressive Llama encoder, binary spherical quantization (BSQ), and a flow-matching diffusion decoder conditioned on text and prompt speech. The repo also includes token-based zero-shot TTS models: an autoregressive (AR) model using LLMs (Qwen2.5, Phi-3.5) and a masked diffusion (MGM) model. Inference pipelines with automatic model downloading from Hugging Face are provided. Training scripts for the tokenizer are partially implemented (dataloader, trainer class), but TTS model training scripts are incomplete. The project has migrated to a new repository (AmphionTeam/Diffusion-Speech-Tokenizer), and this repo is no longer the primary development branch, though recent commits indicate some ongoing activity.
This repository is the companion code for the O'Reilly book 'Hands-On Large Language Models' by Jay Alammar and Maarten Grootendorst. It provides 12 chapters of Jupyter notebooks covering fundamental and advanced LLM topics including tokenization, embeddings, text classification, clustering, prompt engineering, semantic search, multimodal models, fine-tuning, and generation. All notebooks are designed to run on Google Colab with free GPU resources and rely heavily on Hugging Face libraries (transformers, datasets, sentence-transformers, TRL) and external APIs (OpenAI, Cohere). The code is educational in nature, with clear step-by-step explanations and visualizations. While it is not a production application or a novel research pipeline, it serves as a high-quality, reproducible tutorial resource for practitioners learning LLM workflows. The repository includes pinned dependencies, Conda environment setup, and local installation guides, making it relatively easy to reproduce in a controlled environment, though API keys are required for some sections.
This repository is the official companion code for the O'Reilly book 'Natural Language Processing with Transformers' by Tunstall, von Werra, and Wolf. It contains 11 Jupyter notebooks, one per chapter, covering the full spectrum of NLP with Transformers: text classification, named entity recognition, text generation, summarization, question answering, model compression, few-shot learning, and training a transformer from scratch. The code is built on the Hugging Face ecosystem (transformers, datasets, accelerate) and is designed to be run interactively on Colab, Kaggle, or local GPU environments. The notebooks are well-structured with clear section headings, explanatory text, and visualizations, making them an excellent educational resource for learning state-of-the-art NLP techniques. Although the repository is primarily educational, it includes a SageMaker adaptation for some chapters, demonstrating deployment of Hugging Face models on AWS. The codebase is not intended as a production-grade library; rather, it serves as a tutorial and reference for practitioners. The overall quality is solid, with clean, reproducible code patterns, but the reliance on pinned, outdated library versions (e.g., transformers 4.16.2, datasets 1.16.1) and the deprecated Chapter 7 (farm-haystack) indicate moderate technical drift. The concepts remain relevant, but the exact code may require adjustments to run with the latest versions.