Hugging Face: Introduction

Table of Contents

• Module 1: The Hugging Face Hub and Community
  • Course Scenario and Learning Goals
  • Discovering the Hugging Face Ecosystem
  • Finding and Evaluating Models
  • Collaborating with Datasets and Models
  • Exploring Spaces and the Hugging Face Community
• Module 2: Transformers and Model Deployment
  • Introducing the Transformers Library
  • Implementing a Text Generation Pipeline
  • Deploying with Local Execution and the Inference API
  • Showcasing a Project with Spaces
• Summary

Module 1: The Hugging Face Hub and Community

Course Scenario and Learning Goals

This course follows a practical, end-to-end scenario: imagine you are a junior developer at a startup that builds tools for content creators. Your team wants to add an AI feature that helps users brainstorm creative social media posts. The budget for this feature is essentially nothing, and a working prototype is expected within a week. This constraint mirrors a very common real-world situation, and it is exactly the kind of problem the Hugging Face ecosystem was built to solve.

Over the course, the same storyline is used to demonstrate a complete workflow:

1. Explore the Hugging Face Hub and learn how it serves as a central location for discovering and evaluating thousands of community-built models.
2. Use the Transformers library and its pipeline feature to run a text generation model with only a few lines of code.
3. Deploy the resulting model, whether locally on your own machine, through an API, or as an interactive web demo using Spaces.

Everything demonstrated is open source and free to get started with.

mindmap
  root((Hugging Face))
    Hub
      Models
      Datasets
      Spaces
    Transformers Library
      Pipelines
      Tokenizers
      Framework agnostic (PyTorch / TensorFlow)
    Deployment
      Local execution
      Inference API
      Spaces (Gradio)

Discovering the Hugging Face Ecosystem

Hugging Face is formally the company and platform at the forefront of the open-source AI movement. For a developer, the simplest way to think about it is as a central hub for the AI community — similar to a massive public library, but built specifically for machine learning. It is a single place where developers, researchers, and companies can share and collaborate on models, datasets, and demos.

Hugging Face has fundamentally changed how AI models are shared and consumed, and this ties directly into its stated mission: democratizing good machine learning. Historically, building with state-of-the-art AI required massive compute resources and huge budgets. Hugging Face changes that equation by giving everyone access to thousands of powerful pre-trained models that the community has already built and shared.

The Hugging Face home page tagline reads “The AI community building the future.” The main navigation bar is how the ecosystem is explored, and it is organized into three central areas:

flowchart LR
    A[Hugging Face Hub] --> B[Models]
    A --> C[Datasets]
    A --> D[Spaces]
    B --> E[Pre-trained models for text, vision, audio, etc.]
    C --> F[Training / fine-tuning data, previewable in-browser]
    D --> G[Live interactive demos built by the community]

Put together, this forms a centralized platform where the community comes together to share, build, and collaborate on machine learning work.

Finding and Evaluating Models

Continuing the scenario, the next task is to find a pre-trained text generation model on the hub capable of brainstorming social media posts. Before searching for a model, it helps to be a registered member of the community — the Sign Up button in the top-right corner of the home page starts a standard registration flow: enter an email, create a password, and choose a username, then log back in.

With an account in place, the next step is the Models tab. At the time this course was recorded, the number of listed models stood at more than 2 million. With a collection that large, finding the right model requires using the filtering tools provided at the top of the page:

• Tasks filter — selecting Text Generation narrows the list dramatically (from over 2 million down to under 300,000 in the demonstrated example).
• Sort-by dropdown — sorting by Most downloads or Trending is a useful heuristic, since a model used by thousands of people is more likely to be reliable. The default sort is Trending.
• Additional filters are available for number of parameters, supported libraries, and more.

flowchart TD
    A[2M+ models on the Hub] --> B{Apply Task filter e.g. Text Generation}
    B --> C[~300K models]
    C --> D{Sort by Most Downloads / Trending}
    D --> E[Shortlist of candidate models]
    E --> F[Open Model Card]
    F --> G{Test with Inference Widget}
    G -->|Good output| H[Model selected]
    G -->|Poor output| E

Once a candidate model is found, its model card functions like an instruction manual or nutrition label for that model:

• Download statistics and likes act as social proof that the model works.
• A description section explains what the model does.
• An interactive widget uses the live Inference API so the model can be tested directly in the browser — no code or setup required. For example, entering a prompt like “Write a creative Instagram caption about coffee” immediately shows the kind of output the model produces. If the result is decent, that is a good sign; if it is nonsensical, another model may be a better fit.
• Scrolling further down the model card reveals additional information: model overview, performance details, code snippets for how to use the model, and licensing terms.

The core evaluation workflow is therefore: filter by task (and any other relevant criteria), then use the model card and its live demo to judge whether the model is the right fit for the project at hand.

Collaborating with Datasets and Models

Hugging Face is not just a place to find and use models in isolation — it is a collaborative ecosystem. This is illustrated using a more popular model as an example: the 20-billion-parameter version of OpenAI’s gpt-oss series.

On a model’s page, the Community tab functions like a support forum built directly into every model, containing questions, comments, and discussion threads related to that specific model.

Datasets are equally central to the ecosystem, since models are only as good as the data they were trained on. The Datasets tab provides filters similar to the Models tab:

Opening a dataset card shows an in-browser preview of the actual data rows, so there is no need to download gigabytes of data just to check whether a dataset fits a use case. The dataset card also lists models that were trained or fine-tuned on that dataset — a useful shortcut if someone has already fine-tuned a model for a very similar need. Datasets also have their own Community tab, where people share how they use the data, report issues, and ask questions.

Returning to a model page, three dropdown menus provide further paths for working with the model:

flowchart LR
    M[Model Page] --> T[Train]
    M --> D[Deploy]
    M --> U[Use this model]

    T --> T1[AutoTrain: no-code fine-tuning]
    T --> T2[SageMaker integration for AWS users]

    D --> D1[Inference Providers: serverless API access]
    D --> D2[Inference Endpoints: dedicated production infrastructure]
    D --> D3[Spaces: interactive web demo]

    U --> U1[Code snippets for the Transformers library]
    U --> U2[One-click Notebooks: Google Colab / Kaggle]

• Train offers AutoTrain, a no-code option for fine-tuning a model on custom data without writing training scripts, as well as SageMaker integration for AWS-based workflows.
• Deploy lists the ways a model can actually be used in production or in a prototype: Inference Providers for serverless API access (ideal for prototypes), Inference Endpoints for dedicated infrastructure, and Spaces for building a web demo.
• Use this model shows exactly how to load the model with the Transformers library, and also links to one-click cloud notebooks (Google Colab and Kaggle) so the model can be run without any local setup.

The Files and versions tab reveals the actual artifacts that make up the model: the model weights, configuration files, and tokenizer files. A large file such as model.safetensors (for example, 4.79 GB in the demonstrated model) represents the trained neural network itself, while smaller files handle tasks such as converting text into the tokens the model understands.

Every change to these files is tracked through a full commit history, visible on the right side of the Files and versions tab (for example, “History: 16 commits”). This means that if a model update breaks something for a given use case, an older version can always be retrieved.

Exploring Spaces and the Hugging Face Community

Spaces is where AI models become real, usable applications. Opening the Spaces tab reveals what could be described as an “App Store of AI” — not just models sitting in a repository, but live, interactive web applications: chatbots, image generators, music creators, document analyzers, and even full games, all built by the community and running continuously.

As a demonstration, a Background Removal space is opened, and an image is uploaded and submitted. Processing time depends on GPU availability, but the result is a fully functional background removal performed entirely through the browser, with no local installation or code required.

Every Space is open source. The Files tab of a Space exposes all of the code behind the application, meaning that a similar space can be read, learned from, forked, and modified for a new purpose.

The Community section (accessible from the main navigation) brings together three complementary areas:

The overall picture is that Hugging Face is not just infrastructure for AI — it is a complete ecosystem where models become applications, research becomes runnable code, and developers of every skill level, from students to enterprises, can build with AI.

Module 2: Transformers and Model Deployment

Introducing the Transformers Library

Having explored the platform and identified usable models, the next step is implementation — and that is the role of the Transformers library, arguably one of the most important tools in a modern AI developer’s toolkit.

At its core, Transformers is a Python library that makes using state-of-the-art AI models dramatically simpler. Before Transformers existed, using a model like GPT required understanding the intricate details of the model architecture, dealing with different underlying frameworks, and handling tokenization manually.

Transformers is powerful for three main reasons:

1. Framework agnostic — it works with both PyTorch and TensorFlow, and models can even be converted between frameworks, avoiding lock-in to a single ecosystem.
2. Automatic complex processing — every model needs text converted into numbers it can understand, a process called tokenization. Different models use different tokenization schemes, and Transformers handles this automatically.
3. Unified API — whether the task is text generation, translation, question answering, or image classification, the code structure looks essentially the same. One pattern is learned and reused everywhere.

sequenceDiagram
    participant Dev as Developer code
    participant Pipe as pipeline()
    participant Tok as Tokenizer
    participant Model as Model (PyTorch/TensorFlow)

    Dev->>Pipe: pipeline('text-generation', model=...)
    Pipe->>Model: Download & load weights (if not cached)
    Dev->>Pipe: generator(prompt)
    Pipe->>Tok: Encode prompt into tokens
    Tok->>Model: Token IDs
    Model->>Model: Run inference
    Model->>Tok: Output token IDs
    Tok->>Pipe: Decode tokens into text
    Pipe->>Dev: Return generated_text

The library’s pipeline feature abstracts all of this behind a very small amount of code. Using Google Colab (a free, virtually zero-setup notebook environment at colab.research.google.com), a runtime is connected and the library installed:

pip install transformers

A minimal working text generation example looks like this:

from transformers import pipeline

# Create a text generation pipeline
generator = pipeline('text-generation', model='gpt2')

# Generate some text
result = generator("The future of AI is", max_length=50)
print(result)

Running this downloads the model, loads it, handles tokenization, runs inference, and decodes the output back into text — all of that complexity hidden behind a simple function call. A different model ID can be substituted directly, for example a smaller or more specialized text-generation model copied from its Hub page:

generator = pipeline('text-generation', model='baidu/ERNIE-4.5-21B-A3B-Thinking')

result = generator("The future of AI is", max_length=50)
print(result)

The pipeline API supports many tasks beyond text generation out of the box, including sentiment analysis, named entity recognition, translation, summarization, question answering, and computer-vision tasks such as image classification and object detection.

Implementing a Text Generation Pipeline

The default GPT-2 output is a reasonable proof of concept, but it is not refined enough for production social media content. To improve quality, the course switches to a more recent and capable model: Google’s Gemma 2, specifically the 2B Instruct variant. It is newer, has been fine-tuned to follow instructions well, and at 2 billion parameters is still small enough to run at reasonable speed.

Gemma is a gated model — Google requires users to request access (typically for safety and compliance tracking), which is granted after accepting the model’s terms and conditions, usually instantly.

Even after being granted access on the Hub, a notebook environment must separately authenticate using a personal access token:

from huggingface_hub import login
login()

Running this prompts for a token, which is created from the Hugging Face Tokens page (linked directly from the login prompt in Colab). A new token is created with at least Read permissions, then copied and pasted into the prompt.

With authentication complete, the Gemma pipeline is created, specifying device_map="auto" so that a GPU is used automatically if one is available:

from transformers import pipeline

generator = pipeline(
    'text-generation',
    model='google/gemma-2-2b-it',
    device_map="auto"
)

Loading downloads roughly 5 GB of model weights. Once loaded, a carefully worded prompt is passed to the generator, since instruction-tuned models like Gemma can follow detailed instructions closely:

prompt = "Write one Instagram caption about morning coffee. Include emojis. Maximum 150 characters.\n\nCaption: "

result = generator(
    prompt,
    max_new_tokens=60,  # Note: Gemma uses max_new_tokens, not max_length
    temperature=0.7,
    do_sample=True,
    top_p=0.9,
    repetition_penalty=1.25,
    num_return_sequences=3
)

print(result)

The generation parameters each control a different aspect of the output:

Each returned result includes the entire original prompt, followed by two newlines, followed by the actual generated caption — this is how Gemma formats its responses. To isolate just the caption text:

for r in result:
    # Split on double newline to get just the caption
    caption = r['generated_text'].split('\n\n')[1].strip()
    print(caption)
    print(f"Length: {len(caption)} characters\n")

To make this reusable for the project, the logic is wrapped into a function, generate_social_content, parameterized by topic and platform. Twitter and Instagram require different tones and length limits, so the function branches on the platform and raises an error for anything unsupported:

def generate_social_content(topic, platform):
    if platform == "twitter":
        instructions = "thought provoking, engaging tweet"
        char_limit = 280
    elif platform == "instagram":
        instructions = "Instagram caption with emojis and a casual, friendly tone"
        char_limit = 150
    else:
        raise ValueError("Please choose from 'twitter' or 'instagram'")

    prompt = f"Generate one {instructions} about '{topic}'. The post must be under {char_limit} characters.\n\nPost: "

    results = generator(
        prompt,
        max_new_tokens=100,
        temperature=0.8,
        do_sample=True,
        top_p=0.9,
        repetition_penalty=1.25,
        pad_token_id=generator.tokenizer.eos_token_id
    )

    clean_posts = []
    for r in results:
        full_text = r['generated_text']
        if prompt in full_text:
            caption = full_text.split(prompt, 1)[1].strip()

            # Remove any explanations or extra content after the caption
            if '\n\n' in caption:
                caption = caption.split('\n\n')[0].strip()
            elif '\n*' in caption:  # Sometimes explanations start with *
                caption = caption.split('\n*')[0].strip()

    return clean_posts

Testing the function for each platform demonstrates the difference in tone:

# Example usage
posts = generate_social_content("launching our new productivity app", "twitter")
for post in posts:
    print(f"Post: {post}")
    print(f"Length: {len(post)} characters\n")

The Twitter output is a well-formed, thought-provoking tweet with a character count, while the Instagram version of the same call produces a friendlier tone with more emojis. Although the function’s output still has some rough edges, it behaves as intended and forms the basis for the deployment step that follows.

Deploying with Local Execution and the Inference API

With text generation working inside a notebook, the next question is how to actually deploy it. Two complementary options are demonstrated: running the model locally as a script, and calling it through the Hugging Face Inference API.

Option 1 — Local Execution

The simplest deployment path is to turn the notebook into a standalone Python script. All imports, the Hugging Face login, model pipeline creation, and the generate_social_content function are copied into a new file, social_generator.py, along with a small command-line interface that prompts the user for a topic and a platform:

from transformers import pipeline
from huggingface_hub import login

# Login to Hugging Face
login("HF-TOKEN")  # Replace with your actual token

print("Loading model... this might take a minute...")
generator = pipeline(
    'text-generation',
    model='google/gemma-2-2b-it',
    device_map="auto"
)

def generate_social_content(topic, platform):
  if platform == "twitter":
    instructions = "thought provoking, engaging tweet"
    char_limit = 280
  elif platform == "instagram":
    instructions = "instagram caption with emojis and a casual, friendly tone"
    char_limit = 150
  else:
    raise ValueError("Please choose from twitter or instagram")

  prompt = f"Generate one {instructions} about '{topic}'. The post must be under {char_limit} characters.\n\n Post: "

  results = generator(
      prompt,
      max_new_tokens=60,
      temperature=0.8,
      do_sample=True,
      top_p=0.9,
      repetition_penalty=1.25,
      pad_token_id = generator.tokenizer.eos_token_id
  )

  clean_posts = []
  for r in results:
    full_text = r['generated_text']
    if prompt in full_text:
      caption = full_text.split(prompt, 1)[1].strip()

      if '\n\n' in caption:
        caption = caption.split('\n\n')[0].strip()
      elif '\n*' in caption:
        caption = caption.split('\n*')[0].strip()
      
      clean_posts.append(caption)

  return clean_posts

if __name__ == "__main__":
    print("\nSocial Media Content Generator")
    print("-" * 30)
    
    topic = input("What's your topic? ")
    platform = input("Platform (twitter/instagram)? ").lower()
    
    print(f"\nGenerating {platform} content about '{topic}'...\n")
    
    posts = generate_social_content(topic, platform)
    
    for post in posts:
        print(f"Post: {post}")

Running this from a terminal (inside an activated virtual environment with the necessary packages installed) prompts for a topic — for example “Launching a jewelry business” — and a platform — for example “Instagram” — and produces a generated post with no notebook required.

The downside of local execution is significant: every user who wants to run the script needs Python, the supporting packages, and a roughly 5 GB model download on their own machine, and without a GPU, generation is slow.

Option 2 — The Hugging Face Inference API

The Inference API solves the distribution problem: instead of shipping the model to every machine, requests are sent to Hugging Face’s hosted infrastructure. On the Gemma model page, the Deploy → Inference Providers section shows several equivalent ways to call the model:

The huggingface_hub approach is the most straightforward. The client is created, and the earlier generation function is adapted to call the hosted model instead of a local pipeline:

from huggingface_hub import InferenceClient
import os

# Initialize client with token from environment variable
client = InferenceClient(
    provider="nebius",
    api_key=os.environ.get("HF_TOKEN")
)

def generate_social_post(topic, platform):
    if platform == "twitter":
        prompt = f"Write a thought provoking tweet about {topic}. Max 280 chars."
    else:
        prompt = f"Write an Instagram caption with emojis about {topic}. Max 150 chars."
    
    completion = client.chat.completions.create(
        model="google/gemma-2-2b-it",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=100,
        temperature=0.8
    )
    
    return completion.choices[0].message.content

# Use it
topic = input("Topic: ")
platform = input("Platform (twitter/instagram): ").lower()

post = generate_social_post(topic, platform)
print(f"\nYour {platform} post:")
print(post)

This is saved as api_generator.py. Anyone with Python installed can now run it without downloading the model at all — no 5 GB download, no GPU required, and generation happens almost instantly, since the heavy computation runs on Hugging Face’s servers.

sequenceDiagram
    participant User
    participant Script as api_generator.py
    participant HF as Hugging Face Inference API
    participant Model as Hosted Gemma 2 model

    User->>Script: Enter topic + platform
    Script->>HF: chat.completions.create(model, messages)
    HF->>Model: Run inference on hosted infrastructure
    Model->>HF: Generated text
    HF->>Script: completion.choices[0].message.content
    Script->>User: Print generated post

Showcasing a Project with Spaces

Local scripts and API calls are still not ideal for non-technical stakeholders, such as a marketing team — they need something they can simply click and use. This is exactly the problem Hugging Face Spaces solves: turning code into a shareable web application with no installation and no terminal required.

To create a Space:

1. From the Hugging Face home page, open your profile menu and select New Space.
2. Give the Space a name, for example social-content-generator.
3. Choose an SDK. Three options are available:

4. Select the free CPU hardware tier to start.
5. Click Create Space.

The getting-started page for a new Space offers to clone it locally via git, or to create files directly in the browser. Creating app.py directly in the browser is the fastest path for a small demo like this one.

Before writing code, the Hugging Face access token must be made available to the Space as a secret, since it cannot be hardcoded into the source file:

1. Go to the Space’s Settings.
2. Find Variables and secrets, then click New secret.
3. Name the secret HF_TOKEN (matching the name used in the code) and paste in the token value.

With the secret configured, app.py is written with the imports, the API client initialization, the generation function, and finally a Gradio interface definition:

import gradio as gr
from huggingface_hub import InferenceClient
import os

client = InferenceClient(
    provider="nebius",
    api_key=os.environ.get("HF_TOKEN")
)

def generate_social_post(topic, platform):
    if platform == "twitter":
        prompt = f"Write a thought provoking tweet about {topic}. Max 280 chars."
    else:
        prompt = f"Write an Instagram caption with emojis about {topic}. Max 150 chars."

    completion = client.chat.completions.create(
        model="google/gemma-2-2b-it",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=100,
        temperature=0.8
    )

    return completion.choices[0].message.content

demo = gr.Interface(
    fn=generate_social_post,
    inputs=[
        gr.Textbox(label="Topic"),
        gr.Dropdown(["twitter", "instagram"], label="Platform")
    ],
    outputs=gr.Textbox(label="Generated Post"),
    title="Social Content Generator",
    description="Generate a social media post for Twitter or Instagram from any topic."
)

demo.launch()

Gradio turns this small amount of Python into a complete web interface: gr.Interface wires the generate_social_post function to a Textbox for the topic and a Dropdown for platform selection as inputs, and a Textbox as the output, along with a title and description for the page.

After committing the new file, the Space’s status progresses through three stages, visible at the top of the page:

stateDiagram-v2
    [*] --> Building
    Building --> Starting
    Starting --> Running
    Running --> [*]

Once the Space reaches the Running state, opening it shows a page with a title, description, input fields, and a submit button. Testing it with a topic such as “Launching a new smart ring” and platform “Twitter” produces a near-instant response: the function runs on Hugging Face’s servers, calls the Gemma API, and returns the result directly in the browser.

The resulting Space can be shared via its URL with anyone — no Python installation and no Hugging Face account required on their end.

Summary

This course walked through the complete journey of building and shipping a small AI-powered feature using the Hugging Face ecosystem, from discovery to a fully shareable web application:

• Discover — the Hugging Face Hub centralizes models, datasets, and Spaces, with over 2 million models covering every AI modality.
• Evaluate — task filters, sort-by-popularity, model cards, and live inference widgets make it possible to test a model before writing a single line of code.
• Collaborate — Community tabs on models, datasets, and papers, plus Daily Papers and Blog Articles, turn the Hub into a living ecosystem rather than a static repository.
• Implement — the Transformers library’s pipeline abstraction hides tokenization, model loading, and inference behind a unified, framework-agnostic API.
• Tune generation — parameters such as temperature, top_p, repetition_penalty, and max_new_tokens shape the quality and style of generated text.
• Deploy — local execution offers full control at the cost of setup and speed; the Inference API offers fast, dependency-free access; Spaces with Gradio offer a fully no-code, shareable web application.

Quick-Reference: Deployment Decision Guide

Checklist for Building an AI Feature on Hugging Face

• Create a Hugging Face account and, if needed, an access token with at least Read permissions.
• Filter the Models tab by task and sort by downloads/trending to shortlist candidates.
• Test shortlisted models directly on their model card using the built-in inference widget.
• Check the Files and versions tab to understand model size and available checkpoints/commits.
• Install transformers and build a working pipeline with pipeline(task, model=...).
• Tune generation parameters (temperature, top_p, repetition_penalty, max_new_tokens) for the desired tone and length.
• Choose a deployment path: local script, Inference API, or a Gradio Space, based on the target audience.
• If using gated or private models, request access and authenticate with huggingface_hub.login().
• For team or public sharing, wrap the logic in a Gradio Interface and publish it as a Space.

Search Terms

hugging · face · llm · application · development · artificial · intelligence · generative · ai · api · community · deployment · execution · inference · local · models · option · spaces · transformers