Hugging Face Hub

The Hugging Face Hub is an open-source repository platform that hosts over one million machine learning models, datasets, and interactive applications. It serves as the central collaboration layer for the ML community, enabling developers to discover, share, version, and deploy models across every modality including text, vision, audio, and multimodal. Model checkpoints on the Hub are compatible with the Transformers, Diffusers, and Datasets libraries, and can be loaded in a few lines of code.

General
Author	Hugging Face
Type	ML Model Repository and Collaboration Platform
Website	huggingface.co
Documentation	Hub Documentation
Repository	github.com/huggingface/huggingface_hub
Models	huggingface.co/models
Datasets	huggingface.co/datasets

Start building with Hugging Face Hub

The Hub is the fastest way to get a pretrained model running in your project. Load any of the 1M+ checkpoints directly into Transformers or Diffusers with a single function call, or browse the Hub to find the right base model for your use case. You can host your own models privately and share fine-tuned adapters with the community without uploading full model weights. During AMD-sponsored hackathons on lablab.ai, participants pull models from the Hub, fine-tune or build on them using AMD Developer Cloud GPUs, and publish their final projects back to the Hub as a Space. Explore what the community has built at Hugging Face Use Cases and Applications.

Hugging Face Hub Tutorials

Getting Started

Hub Documentation Full reference for model cards, repos, and the Hub API
huggingface_hub Python library Python SDK for interacting with the Hub programmatically
Model Hub Browse all publicly available models by task, framework, and license
Datasets Hub Browse curated datasets for training and evaluation

Key Features

1M+ models Text, vision, audio, multimodal, and specialized domain models from top research teams and companies including Meta, Mistral, Google, and Alibaba Cloud.

Private repositories Host proprietary models and datasets with access controls. Upgrade to a PRO or Enterprise account for private inference endpoints.

Model cards Structured documentation for model limitations, intended use, training details, and evaluation results — standardized across all public checkpoints.

Version control Git-based versioning with LFS support for large files. Every model and dataset on the Hub has a full commit history.

Fine-tuned adapters Share and reuse LoRA and PEFT adapters without uploading full model weights. Adapters reference their base model and load in seconds.

Libraries

Transformers Unified API for pretrained models across text, vision, and audio
huggingface_hub Python SDK for Hub authentication, uploads, and downloads
Datasets Efficient access to Hub datasets with streaming and arrow-based caching
PEFT Parameter-efficient fine-tuning (LoRA, QLoRA, prefix tuning)
Optimum-AMD Optimized inference and training for AMD hardware via ROCm

ROCm Plate & Sign OCR (AMD AI League)

An OCR container for AMD AI League Match 2 that reads licence plates and road signs with an open vision-language model running on an AMD GPU through ROCm. How it works: the container starts a resident server that loads Qwen2.5-VL-7B-Instruct once, in bf16 on the GPU, runs a warm-up inference and then listens on a unix socket. Each call to app.py is a thin client, so the harness can start a new process per image without the model ever being reloaded. Image handling accepts PNG, JPEG and TIFF (including 16-bit and multi-page files), applies EXIF rotation, and resizes very large or very small images to keep the number of visual tokens, and the time per image, bounded. The prompt encodes the transcription rules: return the plate number without state names or slogans, keep the province character and letter on Chinese plates, keep every word printed on a sign, and join multi-line text top to bottom. Post-processing removes labels, quotes and explanations, and folds look-alike separators and full-width characters that the grader's normalization would not remove. Reliability: the model weights are baked into the image, so it runs with no network access. Every call writes a valid JSON file, even when something fails. The build checks that torch and torchvision are ROCm builds. The image is built and contract-checked in GitHub Actions, and evaluated against the sample images plus blurred, noisy, glare, low-light and skewed variants.

WaltTrace — Offline Multimodal RAG

WaltTrace answers short factual questions from mixed engineering documents while returning the exact files needed to support each answer. It parses PDF, Word, Excel, CSV, logs and source files, and uses a local vision-language model to read diagrams, scanned pages and equipment labels. Retrieval follows identifiers between incident reports and lookup tables, allowing answers that require more than one document. Generated quotations are checked against indexed source text; unsupported answers are refused with an empty answer and citation list. Qwen2.5-VL-7B runs on a real AMD GPU through ROCm PyTorch. All weights are embedded in the mandated container base, and the application runs without outbound network access. Indexing starts a resident model behind a private Unix socket so each fresh question process avoids reloading the weights. Malformed, unreadable, encrypted and unsupported files are skipped independently. The development report documents actual GPU timings, memory readings, individual answers and citation checks. Public-sample results are development evidence, not a claim about hidden evaluation scores or League points already awarded.

EduAI - Personalized Learning Assistant on AMD

EduMentor AI is an intelligent personalized learning platform designed to revolutionize education. The system analyzes student learning patterns, identifies weak areas, and generates customized lesson plans in real-time. Built with AMD ROCm and OpenAI GPT-4, it provides 24/7 AI tutoring, automated assignment evaluation, and adaptive quizzes. Students get instant doubt clearing, voice-enabled learning, and progress tracking dashboard. For teachers, it offers automated grading, student analytics, and content generation. The platform supports multiple languages including Bengali and English, making quality education accessible to rural students. Our AI model is optimized for low-bandwidth environments and runs efficiently on AMD hardware, ensuring cost-effective deployment for educational institutions across Bangladesh and globally.

LifeOS AI — Personal Digital Twin

LifeOS AI is an intelligent personal digital twin designed to transform how people manage their daily lives using artificial intelligence. It learns user-approved preferences and remembers important information while helping users organize tasks and achieve long-term goals. Unlike traditional AI assistants LifeOS AI maintains personalized context to deliver relevant recommendations across conversations. The platform combines persistent memory with AI agents for task planning and knowledge retrieval. Its Personal Memory Engine stores approved information while Retrieval-Augmented Generation (RAG) retrieves relevant context from personal documents. The Intelligent Planning Agent converts goals into actionable steps and prioritizes tasks based on deadlines and preferences. A Goal Tracking Agent monitors progress and suggests adjustments when plans change. LifeOS AI uses large language models to understand natural language and generate contextual responses. Its agent orchestration system coordinates specialized agents to research information and execute approved actions through connected tools. The platform aims to integrate calendars and productivity applications for seamless task management. The project explores AMD GPU acceleration using compatible open-weight models and ROCm with PyTorch where supported. Performance will be evaluated through response latency and task completion rates alongside retrieval quality and resource utilization. Privacy remains a core principle. Users can inspect and delete stored memories and control connected services. The system will distinguish verified information from AI-generated suggestions and request approval before consequential actions. Built with React and Python or Node.js alongside MongoDB and vector search technologies LifeOS AI aims to create a personalized intelligence layer that makes everyday decisions easier and productivity smarter. LifeOS AI — Think Ahead. Act Smarter. Live Better.

GreYat Web Scout: grounded web retrieval

GreYat Web Scout is a Match 4 agent for intelligent web information retrieval. It takes a natural-language question, with an optional start URL, and returns one exact value together with the page it came from. How it works: a language model (Qwen3-4B-Instruct, served on the AMD GPU by a resident process so each query skips the load time) first plans the lookup: search queries, likely official URLs, and package or project names. In parallel the agent queries several search engines and Wikipedia, and for "latest version" questions it reads the authoritative registries directly (PyPI, npm, GitHub releases, endoflife.date). It fetches the best pages, keeps the passages that match the question, and asks the model to extract a single value and say which passage it came from. Grounding comes first. An answer is only returned if the value appears verbatim on the cited page, so the source URL always backs up the answer. If no page confirms it, the agent returns an empty answer instead of a guess, and answers to "latest" questions are never taken from the model's memory. Version strings and numbers are normalised (v-prefixes, LTS labels, thousands separators) to match the grader. Everything runs locally on AMD ROCm with no external API keys. In development, on a 30-question set covering facts, ports, people, dates and live package versions, the pipeline answered 26 correctly (tested with a hosted stand-in model, since GPU time was not available).

WebScout Exact: Match 4 Retrieval Agent

WebScout Exact is my entry for Match 4 of the AMD AI League (Intelligent Web Information Retrieval). The agent takes a natural-language question, optionally with a starting URL, and returns one exact value plus the source page it came from, not a summary or a list of links. It runs as a single Docker container built on the official ROCm PyTorch image, so it works on AMD Instinct GPUs. Pipeline: the question is classified into an answer type (number, date, version, price, name, phone and so on); the agent fetches the given URL or searches the web, follows the most relevant links, and cleans each page into plain text. Candidate values are extracted with rules for each answer type and checked by a local Qwen3-4B-Instruct model served from the container on the AMD GPU, which picks the value that best matches the question. The answer is normalised the way the grader compares answers and written to a JSON file with the answer, source URL and confidence. If the model is not available, a rule-based path still answers. Each query is designed to finish well under 30 seconds and the model loads during the startup window. On my own held-out test set it answers 7 of 8 questions correctly. No API keys are used: all reasoning runs locally on AMD hardware. Image: ghcr.io/solar-depin-hub/amd-match4-agent:v1