zfn9
Introduction
Getting a machine learning model to work is one thing—letting others try it out without installing code or setting up environments is another. That’s where Hugging Face Spaces, combined with Streamlit, comes in. It offers a clean and accessible way to share models and datasets as fully interactive web apps right from your browser.
You don’t need web development experience or cloud infrastructure skills. With just Python and a few files, you can turn your scripts into something people can use and understand. Whether you’re showcasing research or building a tool for others, this setup makes the whole process surprisingly simple.
What Is Hugging Face Spaces and Why Use It?
Hugging Face Spaces is a hosting platform for machine learning demos. It supports frameworks such as Streamlit, Gradio, and static HTML, allowing developers to share their models in a live, interactive format. Spaces work well with the Hugging Face Hub, so you can plug in your model or dataset directly, which speeds up development and reduces setup hassle.
No server configuration is required, and the platform is beginner-friendly. If you’ve used the Hugging Face Hub to publish a model, Spaces is a natural next step. Whether you’re creating something for personal use or to share with the public, Spaces gives you a browser-based interface to host Python apps that run your models in real-time.
Streamlit is a great fit here because of its simplicity. You can use it to build interactive apps using only Python. Adding a text input, button, or chart takes just one or two lines of code. It’s flexible enough to support a range of use cases—classification, summarization, question answering, data visualizations, and more—while staying easy to maintain.
Setting Up a Streamlit App on Hugging Face Spaces
To begin, create a Hugging Face account and sign in. Navigate to the Spaces tab and click “Create New Space.” Choose a name, visibility (public or private), and license, and select “Streamlit” as the SDK. Once created, your Space acts as a Git repository. You can use the web editor or clone it locally.
At a minimum, your Space needs an app.py file and a requirements.txt file. Hugging Face installs dependencies automatically. Your app.py script will contain the Streamlit code, while requirements.txt lists the Python libraries your app needs.
Here’s an example:
# app.py
import streamlit as st
from transformers import pipeline
st.title("Text Sentiment Classifier")
classifier = pipeline("sentiment-analysis")
text = st.text_area("Enter text to analyze:")
if st.button("Classify"):
result = classifier(text)
st.write(result)
This short script sets up a sentiment analysis app that runs in the browser. It uses a Hugging Face model and returns the result when a button is clicked. There’s no need to install anything locally—users just visit your Space and interact with the app.
Integrating Your Own Models and Datasets
You’re not limited to using pre-trained models. You can upload your own model to the Hugging Face Hub and use it in your Space. Use transformers-cli to push your model and load it using from_pretrained() inside your app.
Here’s how you might use your own model:
from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
tokenizer = AutoTokenizer.from_pretrained("your-username/your-model")
model = AutoModelForSequenceClassification.from_pretrained("your-username/your-model")
classifier = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
This connects your custom model to the Streamlit interface. You can modify the app to suit any task your model supports—translation, classification, summarization, and more.
The same goes for datasets. If you’ve uploaded a dataset to the Hugging Face Hub, you can access it using the datasets library:
from datasets import load_dataset
data = load_dataset("your-username/your-dataset")
st.write(data["train"][0])
This makes it possible to build applications that let users explore datasets, apply filters, or analyze records. You can build forms, charts, and even custom visualizations using Streamlit widgets.
Both models and datasets hosted on Hugging Face are versioned and tracked, which helps with reproducibility and collaboration. Any updates pushed to your model or dataset are automatically reflected in the hosted app without requiring extra steps.
Benefits and Limitations of Hosting with Spaces and Streamlit
One of the biggest advantages of Hugging Face Spaces is how little work it takes to publish a model-backed app. There’s no need to manage cloud servers or install backend software. You write Python code, push it to your Space, and Hugging Face handles the rest.
Streamlit makes the process even smoother. It enables fast prototyping and converts Python scripts into usable web applications with minimal effort. It’s great for demos, prototypes, educational tools, and internal testing. Everything stays in Python, so there’s no learning curve related to frontend frameworks.
Still, there are some limitations. The free Spaces tier has restricted memory and CPU, so it’s not well-suited for heavy models or large concurrent traffic. If your model needs a GPU or has strict latency needs, you might need a paid tier or a different deployment approach.
Another thing to keep in mind is that Streamlit is not designed for building complex multi-page apps or apps with advanced routing and user authentication. It’s best used for simple, interactive frontends. For more advanced applications, you’d need something like FastAPI or a custom frontend.
Conclusion
Making your AI models and datasets useful means putting them in the hands of others. Hugging Face Spaces, paired with Streamlit, is a quick way to do just that. It lets you share your work online with almost no friction. You write your Python script, upload it, and it runs—no servers, no complex build process. The connection to the Hugging Face Hub makes it easy to load models and datasets directly into the app. Whether you’re working on research, teaching tools, or demos, this setup brings your work online in a clean, interactive format.
