wentorai/huggingface-inference-guide

Hugging Face Inference API Guide

Overview

The Hugging Face Inference API provides instant access to thousands of pre-trained machine learning models for natural language processing, computer vision, audio processing, and multimodal tasks. Researchers can run inference on state-of-the-art models without managing infrastructure, GPU resources, or complex deployment pipelines.

The API hosts models from the Hugging Face Hub, which contains over 500,000 models contributed by the research community. This includes transformer models for text classification, named entity recognition, summarization, translation, question answering, text generation, and image classification. For academic researchers, the Inference API is invaluable for rapid prototyping, benchmark evaluation, and integrating ML capabilities into research workflows without dedicated compute resources.

The free tier provides access to a broad selection of models with rate limits suitable for development and small-scale research. An API token is required for authentication, available for free at huggingface.co.

Authentication

A free Hugging Face API token is required. Create an account and generate a token at https://huggingface.co/settings/tokens.

Store your token securely in an environment variable:

export HF_API_TOKEN=$HF_API_TOKEN

curl -X POST "https://api-inference.huggingface.co/models/bert-base-uncased" \
  -H "Authorization: Bearer $HF_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"inputs": "The goal of life is [MASK]."}'

Core Endpoints

Text Classification (Sentiment Analysis)

POST https://api-inference.huggingface.co/models/{model_id}

curl -s -X POST \
  "https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english" \
  -H "Authorization: Bearer $HF_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"inputs": "This research methodology provides robust and reproducible results."}' \
  | python3 -m json.tool

Named Entity Recognition

curl -s -X POST \
  "https://api-inference.huggingface.co/models/dslim/bert-base-NER" \
  -H "Authorization: Bearer $HF_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"inputs": "Dr. Marie Curie conducted research at the University of Paris on radioactivity."}' \
  | python3 -m json.tool

Text Summarization

curl -s -X POST \
  "https://api-inference.huggingface.co/models/facebook/bart-large-cnn" \
  -H "Authorization: Bearer $HF_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": "The study of quantum computing has seen tremendous advances in the past decade. Researchers have demonstrated quantum supremacy with processors containing over 100 qubits. Error correction remains a significant challenge, but recent breakthroughs in topological qubits and surface codes suggest viable paths forward. Applications in drug discovery, materials science, and cryptography are expected to be among the first practical use cases.",
    "parameters": {"max_length": 80, "min_length": 30}
  }' | python3 -m json.tool

Zero-Shot Classification

Classify text into arbitrary categories without fine-tuning.

curl -s -X POST \
  "https://api-inference.huggingface.co/models/facebook/bart-large-mnli" \
  -H "Authorization: Bearer $HF_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "inputs": "New CRISPR technique enables precise gene editing in human stem cells",
    "parameters": {"candidate_labels": ["biology", "computer science", "physics", "economics"]}
  }' | python3 -m json.tool

Python Example: Batch Sentiment Analysis of Paper Abstracts

import requests
import os
import time

API_URL = "https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english"
HEADERS = {"Authorization": f"Bearer {os.environ['HF_API_TOKEN']}"}

def classify_sentiment(texts):
    """Classify sentiment for a batch of texts."""
    response = requests.post(API_URL, headers=HEADERS, json={"inputs": texts})
    if response.status_code == 503:
        # Model is loading, wait and retry
        wait_time = response.json().get("estimated_time", 20)
        print(f"Model loading, waiting {wait_time:.0f}s...")
        time.sleep(wait_time)
        response = requests.post(API_URL, headers=HEADERS, json={"inputs": texts})
    response.raise_for_status()
    return response.json()

abstracts = [
    "Our results demonstrate a significant improvement over baseline methods.",
    "The proposed approach failed to achieve meaningful gains on the benchmark.",
    "We present preliminary findings that warrant further investigation.",
]

results = classify_sentiment(abstracts)
for abstract, result in zip(abstracts, results):
    top = max(result, key=lambda x: x["score"])
    print(f"Sentiment: {top['label']} ({top['score']:.3f})")
    print(f"  Text: {abstract[:80]}...")
    print()

Python Example: Research Paper Topic Classification

import requests
import os

ZSC_URL = "https://api-inference.huggingface.co/models/facebook/bart-large-mnli"
HEADERS = {"Authorization": f"Bearer {os.environ['HF_API_TOKEN']}"}

def classify_paper(abstract, categories):
    """Classify a paper abstract into research categories."""
    payload = {
        "inputs": abstract,
        "parameters": {"candidate_labels": categories}
    }
    resp = requests.post(ZSC_URL, headers=HEADERS, json=payload)
    resp.raise_for_status()
    return resp.json()

categories = [
    "machine learning",
    "computational biology",
    "natural language processing",
    "computer vision",
    "reinforcement learning",
    "quantum computing"
]

abstract = "We propose a novel transformer architecture for protein structure prediction that achieves state-of-the-art results on CASP benchmarks."
result = classify_paper(abstract, categories)

print("Topic classification:")
for label, score in zip(result["labels"], result["scores"]):
    bar = "#" * int(score * 40)
    print(f"  {label:<30} {score:.3f} {bar}")

Common Research Patterns

Literature Screening: Use zero-shot classification to automatically categorize and filter large collections of paper abstracts by research topic, methodology, or relevance to a specific research question.

Sentiment and Stance Detection: Analyze the tone and conclusions of research papers, review comments, or social media discussions about scientific topics using sentiment analysis models.

Named Entity Extraction: Extract researcher names, institutions, chemical compounds, gene names, and other domain-specific entities from unstructured text in papers and reports.

Automated Summarization: Generate concise summaries of lengthy research papers or grant proposals to accelerate literature review workflows.

Multilingual Research: Use translation and multilingual models to access and analyze research published in languages other than English.

Rate Limits and Best Practices

• Free tier: Rate-limited; approximately 1,000 requests per day depending on model and load
• Model loading: Cold models may take 20-60 seconds to load; handle 503 responses with retry logic
• Batch inputs: Send multiple texts as an array in a single request to improve throughput
• Model selection: Use distilled or smaller variants (e.g., distilbert instead of bert-large) for faster inference
• Timeouts: Set request timeouts to 60+ seconds for large models or first requests after cold start
• Caching: Cache inference results for identical inputs to avoid redundant API calls
• Pro tier: For production workloads, consider the Inference Endpoints or Pro subscription for dedicated resources

References

• Hugging Face Inference API Documentation: https://huggingface.co/docs/api-inference/index
• Hugging Face Model Hub: https://huggingface.co/models
• Hugging Face API Token Settings: https://huggingface.co/settings/tokens
• Hugging Face Tasks Overview: https://huggingface.co/tasks