Browse skills

Create short video clips from text or still images with LTX-2.3 22B. Generate supporting footage, animated backgrounds, or moving portraits while specifying camera motion, lighting, dimensions, and duration, with clips around five seconds by default.

• Generate supporting footage for narrated videos
• Add subtle motion to slide backgrounds
• Animate still portraits

Turn a written brief into an explainer video by generating narration, images, music, and optional talking presenters. Assemble scenes with Remotion, adjust their timing to the generated audio, review still frames, and render an MP4.

• Creating a narrated product introduction
• Turning a sprint review into a video
• Adding an animated presenter to a scene

Use Hugging Face Transformers to load pretrained models, generate text, and classify text, images, or audio. Prepare model inputs, control generation settings, and fine-tune models on custom datasets with the Trainer API.

• Prototype text, image, or audio classification
• Configure text generation and conversational responses
• Fine-tune a model on a custom dataset

Work with Waypoint models to analyze microbiome samples, the communities of microbes in a sample. Convert taxonomic abundance tables, generate numerical sample representations, configure further training for prediction tasks, and evaluate models on the Compass benchmark.

• Convert microbiome abundance tables into Waypoint inputs
• Generate sample vectors for clustering and visualization
• Configure further training with sample labels

Forecast sales and other time series with Google’s TimesFM without task-specific training. Prepare regularly spaced CSV data, export predicted values and uncertainty ranges, add explanatory variables, and evaluate forecasts against held-out observations.

• Forecast monthly sales or revenue from CSV data
• Export predicted values with uncertainty ranges
• Forecast with additional explanatory variables

Use PathML for local pathology image research, from loading whole-slide images and splitting them into tiles to preprocessing and quality checks. Plan multiplex measurements, analyze spatial relationships between cells, and run model inference in bounded batches.

• Planning tile extraction from whole-slide images
• Reviewing preprocessing and image quality
• Validating multiplex measurements and spatial graphs

Find scientific datasets, AI models, methodology posts, and interactive demos through the Hugging Science catalog. Compare candidates for a research task and verify their licenses, input formats, access requirements, and supported ways to run them.

• Finding models for protein or genome analysis
• Selecting datasets for scientific machine learning
• Comparing resource licenses and runtime requirements

Analyze Neuropixels neural recordings with SpikeInterface, from loading and preprocessing to motion correction and spike sorting, which separates signals by neuron. Calculate quality metrics, review candidate units, and export plots and data for further inspection.

• Inspect and preprocess SpikeGLX, Open Ephys, or NWB recordings
• Check and correct movement-related drift before spike sorting
• Evaluate and select units using quality metrics

Prepare and analyze genomic intervals, regions defined by chromosome coordinates, with Gtars. Validate BED files, compare overlaps and coverage, combine region sets, and plan tokenization or reference storage while tracking data provenance and resource limits.

• Validating BED coordinates and reference assemblies
• Counting overlaps and comparing genomic region sets
• Converting genomic intervals into token IDs

Plan and audit HypoGeniC workflows that use language models to propose patterns from labeled text. Check configurations, dataset splits, cost limits, and saved predictions while keeping candidate hypotheses separate from scientific confirmation.

• Reviewing task settings before a HypoGeniC run
• Checking duplicates across training and test data
• Estimating token and cost limits before model calls

Predict spatial gene expression from H&E-stained tissue images using DeepSpot-M. Query a released panel of about 19,000 genes and combine predictions from small image tiles into slide-wide maps for research analysis.

• Mapping predicted marker-gene expression across a tumor section
• Predicting expression across slides without matching gene-expression assays
• Adding predicted expression to a histology image analysis pipeline

Prepare genomic interval data for machine learning by checking BED files, reference genome consistency, and model compatibility. Plan Region2Vec or scEmbed workflows and assess shared reference regions using local validation and planning helpers.

• Check BED coordinates and reference genome consistency
• Plan Region2Vec or scEmbed training
• Inspect model and tokenizer compatibility

Measure denoising latency in SGLang diffusion models and identify slow operations with profiler traces. Compare performance and output quality on the same GPUs, check existing optimizations, and gather evidence before starting low-level kernel work.

• Measuring diffusion denoising latency
• Ranking slow operations from profiler traces
• Checking whether existing optimizations address a bottleneck

Add a model page to the SGLang Cookbook using shared templates. Organize verified launch settings and measured benchmarks, create configuration files and documentation, and update navigation, vendor cards, and page validation.

• Add documentation for a newly supported model
• Organize verified launch recipes by hardware
• Publish measured speed and accuracy results

Choose SGLang Diffusion settings for a specific model, GPU, and memory budget. Compare generation speed, memory use, and output quality to select command-line options, including CPU offloading, multiple GPUs, caching, and reduced precision.

• Choosing generation settings for a specific model and GPU
• Reducing GPU memory use to fit a memory budget
• Comparing performance settings across multiple GPUs

Analyze LLM serving traces to identify GPU time usage, opportunities to run operations concurrently, and known patterns for combining operations. Produce three consistent tables from saved traces or live captures on supported servers.

• Identify GPU operations that dominate inference time
• Compare input processing and token generation
• Trace GPU operations back to Python code

Add a diffusion model or Diffusers generation pipeline to SGLang. Examine reference code, choose a suitable pipeline structure, reuse existing components, and implement model settings and processing stages, with guidance for later multi-GPU support.

• Adding a new diffusion model to SGLang
• Porting a Diffusers generation pipeline
• Adding a variant by reusing existing model components

Package an existing custom diffusers block into a directory ready for Hub upload. Select a class from a Python file and save its source, configuration, and associated files so others can load the block.

• Preparing a custom block for Hub distribution
• Selecting one block class from a Python file
• Creating the directory layout needed to load a shared block

Build a screening pipeline for web pages, PDFs, and images before an AI agent reads them. Extract hidden text, check for malicious instructions with detection models, and record decisions to block or allow content.

• Screening external content before an agent reads it
• Checking uploaded PDFs and images for hidden instructions
• Scanning documents before adding them to a knowledge base

Screen AI application inputs and historical logs for prompt injection, where malicious instructions try to redirect the model. Combine pattern matching, text structure scoring, and a DeBERTa classifier to flag suspicious content and produce JSON results.

• Screening chatbot and AI agent inputs
• Checking external text used in retrieval-based AI applications
• Auditing historical interaction logs for injection attempts

Add checks to LLM prompts and responses using Llama Guard 3, NeMo Guardrails, and LLM Guard. Configure content screening, conversation boundaries, and sensitive-data filtering, then measure blocking and false-positive rates with labeled test prompts.

• Adding runtime safety checks to LLM, RAG, or agent apps
• Screening prompts for injection and jailbreak attempts
• Filtering sensitive or toxic model responses

Forecast sales, demand, or sensor readings with Google's pretrained TimesFM model, without custom training. Check hardware and dataset memory needs, include external factors such as prices or holidays, and obtain forecasts with uncertainty ranges.

• Forecasting future sales or demand from CSV data
• Including prices and holidays in sales forecasts
• Forecasting multiple stores' time series in batches

Generate embeddings, numerical representations of text or images, for meaning-based search, similarity comparisons, and document grouping. The skill guides model selection, multilingual processing, local execution, and integration with retrieval workflows.

• Generate document embeddings for RAG
• Find sentences with similar meanings
• Group documents by topic

Build safety checks for LLM prompts and responses using Meta's LlamaGuard moderation model. Classify potentially harmful content, block flagged messages, serve checks through an API, and integrate them with NeMo Guardrails.

• Checking prompts before sending them to an LLM
• Filtering responses before displaying them
• Building a moderation API