Browse skills

Adapt large language models to specific tasks through fine-tuning, or additional training. Prepares and validates datasets, configures LoRA or QLoRA to train a small subset of parameters, and supplies training settings, evaluation scripts, and deployment optimization guidance.

• Preparing and validating JSONL training data
• Choosing LoRA or QLoRA for available GPU memory
• Configuring training and monitoring overfitting

Find and run local AI models with llama.cpp. Choose GGUF model files and quantization levels that fit available memory, launch a command line session or local server, and test an OpenAI-compatible API on your computer.

• Find models to run on a local computer
• Choose quantization for available memory
• Launch and test a local OpenAI-compatible API

Write and debug code for further training large language models with TRL. Match training methods to dataset formats, configure supervised or preference-based training, and set up reward functions through Python or the command line.

• Training a language model on example responses
• Training with preferred and rejected response pairs
• Debugging GRPO reward functions and batch settings

Explore Hugging Face datasets through the Dataset Viewer API. Preview and retrieve rows, search text, filter records, inspect sizes and column statistics, and find Parquet download links for further analysis or data extraction.

• Preview dataset contents and data splits
• Search text and filter dataset rows
• Inspect dataset sizes, statistics, and Parquet links

Train or fine-tune language and vision models on Hugging Face Jobs without a local GPU. Covers dataset checks, hardware and cost planning, training monitoring, Hub storage, and GGUF conversion for local use.

• Fine-tune a language model without a local GPU
• Validate preference data before DPO training
• Estimate training costs and choose GPU hardware

Write and review Gradio demos for Hugging Face ZeroGPU. Configure GPU time limits and dependencies, and troubleshoot errors caused by separate worker processes, shared state, concurrent requests, or CUDA package installation.

• Review GPU handlers in a Gradio demo
• Tune GPU duration and quota usage
• Fix PicklingError and stale state across worker processes

Fine-tune vision models on custom images using Hugging Face Jobs cloud GPUs. Covers object detection, image classification, and segmentation—identifying image regions—with dataset validation, hardware selection, cost estimates, monitoring, and saving trained models to the Hub.

• Train an object detector on custom images
• Fine-tune an image classifier
• Adapt SAM/SAM2 to custom image masks

Track machine learning experiments with Trackio by recording training measurements, viewing live dashboards, and flagging diagnostic events. Retrieve metrics and alerts through command-line queries, with JSON output for automated monitoring and experiment review.

• Recording training loss and accuracy
• Flagging loss spikes or stalled training
• Monitoring cloud training through a Space dashboard

Build reusable command-line scripts that fetch and process Hugging Face API data. Combine multiple requests, enrich model information, and produce outputs for further filtering, with built-in help and usage examples for repeated tasks.

• Automating repeated model and dataset lookups
• Combining trending models with metadata and paper links
• Extracting licenses and tags from model cards

Read and summarize AI research papers from Hugging Face or arXiv links and identifiers. Retrieve paper content alongside structured details about authors, related models, datasets, Spaces, and implementation links to support further investigation.

• Summarizing a paper from its URL or arXiv ID
• Finding models, datasets, and Spaces linked to a paper
• Checking authors and implementation links

Manage Hugging Face Hub through the hf command line tool. Download and upload models or datasets, organize cloud storage, manage authentication and local caches, run scheduled jobs, and deploy or maintain model inference services.

• Download or publish models and datasets
• Sync training checkpoints to cloud storage
• Inspect and clean the local cache

Find AI models for a specific task using official Hugging Face benchmark leaderboards. Compare scores, model sizes, and licenses, with memory-based estimates of device suitability and flags for models requiring quantization or API access.

• Compare coding or reasoning models by benchmark scores
• Find model candidates for a laptop's available memory
• Choose models for OCR or speech recognition

Choose a serving container for models deployed on SageMaker. Match the model type to a compatible image, retrieve its address from the AWS catalog, and check regional availability, CPU or GPU variants, and required host settings.

• Choose a container for an LLM deployment
• Select images for embeddings and rerankers
• Check regional image addresses and GPU compatibility

Create interactive web demos and chat interfaces in Python with Gradio. Connect functions to text, image, audio, and file controls, arrange screen layouts, and define what happens when users click buttons or change inputs.

• Turning a Python function into an interactive demo
• Building a chatbot interface
• Adding image and audio inputs and outputs

Build and maintain machine learning apps on Hugging Face Spaces. Choose a suitable app framework and computing hardware, load models, deploy files, and check logs and outputs to diagnose build or runtime problems.

• Publishing a machine learning demo
• Adapting an existing Gradio app for ZeroGPU
• Diagnosing Space build or runtime failures

Evaluate Hugging Face Hub models using inspect-ai or lighteval, with local inference or a provider-backed option. Choose an inference engine, start with a small test, and switch engines when model compatibility requires it.

• Run benchmark evaluations on a local GPU
• Choose an evaluation framework and inference engine
• Check a small sample before a full evaluation

Build JavaScript or TypeScript applications that run text, image, and audio models in browsers or server runtimes. Guides compatible model selection, GPU or CPU execution, caching, and memory cleanup without requiring a Python server.

• Add text classification or translation to a browser app
• Implement image classification and object detection
• Transcribe audio using JavaScript

Build and publish a browser demo for a supplied LoRA, a model adaptation for image or video tasks. Tailor the Gradio interface to its inputs and follow the model’s recommended settings on Hugging Face Spaces.

• Share a trained LoRA through a browser demo
• Build an interface tailored to image editing or video generation
• Apply recommended trigger words and generation settings

Deploy SageMaker endpoints, the services that answer model requests, with automatic capacity scaling, CloudWatch alarms, and resource tags. Supports real-time and asynchronous inference, scaling down to zero instances, deployment checks, and resource cleanup.

• Deploying a real-time model endpoint
• Scaling a sparse workload down to zero instances
• Running long inference jobs asynchronously

Register arXiv papers on Hugging Face Hub, connect them to models and datasets, and manage authorship claims and profile visibility. Create research articles from Markdown templates and convert them into HTML for sharing.

• Registering an arXiv paper on Hugging Face Hub
• Linking papers to models and datasets
• Managing authorship claims and profile visibility

Search Hugging Face Hub for models, datasets, papers, and AI apps. Inspect documentation, use hosted apps for image generation or transcription, and run or schedule code on cloud CPUs and GPUs through an MCP server connection.

• Compare models for a specific task
• Find training datasets
• Generate images or transcribe audio with Spaces

Prepare an isolated Python environment for SageMaker deployments and AWS automation. The skill selects a supported Python version, installs current AWS packages, and checks versions so installation and execution use the same environment.

• Prepare a Python environment for SageMaker deployment
• Separate AWS automation dependencies from system Python
• Check installed AWS package versions

Train sentence-transformers models for search, similarity, and reranking, which reorders search results by relevance. Choose a model type, prepare data, configure training, compare results against a baseline, and publish the trained model to Hugging Face Hub.

• Fine-tuning an embedding model for domain-specific search
• Training a model to rerank search results
• Training SPLADE or ColBERT retrieval models

Estimate inference memory for models on Hugging Face Hub without downloading their weights. Check GPU capacity for Safetensors or GGUF files, with optional estimates for the KV cache, memory used to retain attention data during generation.

• Check whether a model fits on a GPU
• Compare memory estimates for GGUF quantizations
• Estimate KV cache memory for a chosen context length