During the development process of data science projects, we always need to present the results of our findings at certain times. And we sometimes may have doubts about what would be the best way to show these results.
Then, this is where tools like Streamlit, FastAPI and Hugging Face emerge as a quick way to expose functional results and don't need complex implementations.
Prototyping is a process for developing an idea, and it is used in different areas to test or simulate it before launching.
- A prototype is a version of what the product will be.
- Prototyping is the iterative process of idea development.
"So, we will have some prototypes of an idea in the prototyping process."
Prototyping is a fundamental step for any product, idea, or service type because it allows:
- development of an initial version,
- discovery of flaws,
- reduction in costs,
- knowledge of the users' experience,
- testing of features, and
- also, generation of POCs or MVPs of the idea.
There are different tools according to the level of fidelity or similarity between the idea and the final product. These levels can vary according to their concept, aesthetic, and function.
- Low-fidelity prototyping is a paper draft of the idea.
- Mid-fidelity prototyping can be produced in software as a mockup, replicating some fundamental functionalities of the idea. Some tools for prototyping are Figma, Sketch, Miro, and InVision.
- High-fidelity prototype may include some level of programming to replicate the final solution behavior fluidly. Flask and Streamlit are a couple of tools.
Streamlit is a free, open-source, all-Python framework. It enables data scientists to quickly build interactive dashboards and machine learning web apps, without requiring front-end web development experience.
This framework has gained attention and popularity among data scientists and machine learning programmers in recent years. Its growth is due to the fact that it:
- is an easy-to-use tool,
- needs basic knowledge of Python, and
- is compatible with frameworks such as:
- Machine Learning: TensorFlow, PyTorch, Scikit-learn,
- Visualization libraries: Seaborn, Altair, Plotly, and
- Others.
-
Install Streamlit. I recommend you use Conda and set up your environment, but you can use:
pip install streamlit
-
Create a new Python script and import Streamlit with a few Streamlit commands:
import streamlit as st
-
Run it:
streamlit run your_script.py
As soon as you run the script, a local Streamlit server will spin up, and your app will open in a new tab in your default web browser.
Or you can navigate to
http://localhost:8501.
FastAPI is a modern, fast (high-performance) web framework for building APIs with Python. It is based on standard Python type hints, which allows for automatic data validation, serialization, and documentation generation.
FastAPI is designed to be easy to use and highly efficient, providing features such as asynchronous support, dependency injection, and automatic generation of OpenAPI and JSON Schema documentation.
It has gained popularity in the Python community due to its ease of use, performance, and developer-friendly features.
Hugging Face is a company and an open-source community that focuses on natural language processing (NLP) and machine learning.
Hugging Face provides a wide range of tools, libraries, and resources that are widely used by researchers, developers, and data scientists for building, training, and deploying NLP models.
I used a pretrained ViT model for image classification. This model is a fine-tuned version of google/vit-base-patch16-224-in21k on the mnist dataset.
- Clone this repository
(base)$: git clone [email protected]:mafda/ml_with_fastapi_and_streamlit.git
(base)$: cd ml_with_fastapi_and_streamlit- Run the applications
$ docker-compose up- And go to http://localhost:8501
- Change the branch
(base)$: git checkout streamlit-basic- Create the conda environment
(base)$: conda env create -f environment.yml- Activate the environment
(base)$: conda activate ml-app- Run
(ml-app)$: streamlit run src/app.py- And go to http://localhost:8501
Streamlit, FastAPI and Hugging Face could be seen as an opportunity in situations like:
- prototyping quickly,
- creating MVP,
- putting an application into production in a few weeks, and
- sharing a link with the client or user of the system that is being developed.
So, I think it could be a good option when you want to get a prototype of your dashboard/web app up and run it as quickly as possible.
made with 💙 by mafda