Machine learning and data science code is easy to share but hard to use. GitHub overflows with models, algorithms, and datasets. But code is static. Can you play with the models? See the algorithms? Interact with the data? Doing so requires following complex instructions, installing packages, or reading dense code snippets. Frustrated by this, we decided that we need a simple, sharable “play” button for machine learning code.

There are two challenges here. The first is creating apps that make data science and machine learning code interactive. The second is sharing these apps so that the world can experience your work.

A year ago, we addressed the first challenge — creating — by releasing Streamlit, an open-source library that lets you transform Python scripts into interactive apps. Streamlit lets you easily demonstrate algorithms, play with models, manipulate data, and combine all of these superpowers into beautiful apps. The response has been tremendous. We just crossed our millionth download. Hundreds of thousands of Streamlit apps have been created all over the world. But creating great apps only solves half the problem.

Easily deploy and share your Streamlit apps

Today, we address the second challenge — sharing — by announcing a brand-new sharing platform for Streamlit. Streamlit sharing lets you deploy, manage, and share your apps — all for free! If you have a Streamlit app hosted publicly on GitHub, you are now one click away from sharing it with the world.

GitHub and Streamlit — Better Together

Streamlit sharing combines the best of Streamlit with the best of GitHub. From Streamlit you get a simple framework for creating incredibly rich and useful apps. From GitHub you inherit an incredible framework for social collaboration. Paste your GitHub link into Streamlit’s sharing platform and almost instantly you have a live app. Or, click on the menu for any live app and see its source code on GitHub. Collaborate for free simply by forking and editing the code. It’s global, shareable, fork-able, collaborative data science!

Endless Possibilities

Taken together, Streamlit and GitHub enable an incredibly rich and diverse ecosystem of useful apps — from dashboards to deep nets and beyond! (As former Carnegie Mellon folks, we’re especially proud that students taking the Interactive Data Science class now submit their homework using Streamlit sharing 🤗) Here are some awesome examples of shared Streamlit apps that you can play with right now.

While this post has focused on open source applications, Streamlit is also used by thousands of companies to build sophisticated internal data tools. For example, Uber has deployed Streamlit company-wide, enabling data scientists to share their work throughout the company. Streamlit for Teams extends Streamlit’s sharing platform to bring secure, seamless app deployment, management, and collaboration within your enterprise. If you’re interested please sign up for the beta for Streamlit for Teams.

Get Your Invitation to Streamlit Sharing

To celebrate the launch, we’ll be releasing 1,000 invitations for Streamlit sharing — with more invites coming as our server capacity grows. If you don’t have one in your inbox already, please request an invite and we’ll get you one soon.

The Streamlit Play Button

This new sharing superpower completes the Streamlit circle — from creation to sharing, and back again. So create! Share with the world! Let others see your work, fork, merge, and contribute to the cycle of knowledge creation. In that spirit, we offer one last gift: This is our “play” button.

This brand-new badge helps others find and play with your Streamlit app. Embed it right into your GitHub readme.md as follows:

[![Streamlit App](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://share.streamlit.io/yourGitHubName/yourRepo/yourApp/)

Thank you all for inspiring us with your amazing creations. We’re excited to see what you build and share. 🎈

A huge thank you from all of us at Streamlit to all of you in the community — and especially the inaugural Streamlit Creators, Ashish, Charly, Fanilo, José, Jesse, and Synode — for your kindness, your feature requests, your bug reports, and your enthusiasm. Special thanks also to all the launch app creators, Alex, Dan, Ines | Explosion, and finally Tyler who created not only the Goodreads app but also a great sharing tutorial.

Introducing Streamlit Sharing was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

In the ten months since Streamlit was released, the community has created over 250,000 apps for everything from analyzing soccer games to measuring organoids, and from COVID-19 tracking to zero-shot topic classification. Inspired by your creativity, we added file uploaders, color pickers, date ranges, and other features. But as the complexity of serving the community grew, we realized that we needed a more scalable way to grow Streamlit’s functionality. So we’re turning to Streamlit’s best source of ideas: you!

Today, we are excited to announce Streamlit Components, the culmination of a multi-month project to enable the Streamlit community to create and share bits of functionality. Starting in Streamlit version 0.63, you can tap into the component ecosystems of React, Vue, and other frameworks. Create new widgets with custom styles and behaviors or add new visualizations and charting types. The possibilities are endless!

The Streamlit Components Gallery

The first thing you should do is check out the Streamlit Components Gallery to see what others have created and shared.

Each component can be installed with just a single line of code:

pip install some_cool_component

If you don’t find a component that works for you, you can make your own!

Building your own components

Streamlit has a unique, functional style which lets you create rich, interactive experiences in very few lines of code. For example, let’s check out this simple Streamlit app:

import streamlit as st

x = st.slider('x')
st.markdown(f'`{x}` squared is `{x * x}`')

Looking at this code, you can see that Streamlit calls come in two flavors: static components like st.markdown are stateless and only send data to the browser, whereas bidirectional components like st.slider have internal state and send data back from the browser.

Our challenge was to provide an API that embraces Streamlit’s functional style while capturing these use-cases as simply as possible. A few months ago, two amazing Streamlit engineers, Tim Conkling and Henrikh Kantuni, tackled this challenge and came up with a super elegant solution. The result is the new streamlit.components.v1 package which comprises three functions. For static components, we added:

• html(...), which lets you build components out of HTML, Javascript, and CSS
• iframe(...) , which lets you embed external websites

For bidirectional components, we added:

• declare_component(...), which lets you build interactive widgets which bidirectionally communicate between Streamlit and the browser.

Let’s dive into how it works!

Static Components

Let’s start with a simple static component to embed snippets of code called Github gists in your app. Ideally, adding the component should just be a single function call:

# Render a gist
github_gist('tc87', '9382eafdb6eebde0bca0c33080d54b58')

which would render a gist like this:

To create such a component, we start by importing the Streamlit Components library:

import streamlit.components.v1 as components

This somewhat wordy import statement serves two purposes:

1. It versions the components API so that future changes don’t break existing components.
2. It reminds us that we’re starting to use deep magic which we should hide from the user.

Now let’s use the html(...) method to serve up the gist:

This approach has a few awesome properties. First, it’s really simple and functional. In fact, this pattern lets you hide the ugly-looking HTML and wrap it into a pretty, Pythonic function call, github_gist(...). You can wrap code in a function and reuse it throughout your project. (Better yet, put it in a package and share it with the community in the gallery.) Second, note that we can add arbitrary HTML in this component — divs, spans, and yes, scripts! We can do this safely because the component is sandboxed in an iframe which lets us include external scripts without worrying about security problems.

Getting widget with it!

What if you want to create a stateful bidirectional component that passes information back to Python from the browser, or in other words, a widget? You can do this too! For example, let’s create a counter component:

count = counter(name="Fanilo")
st.write('The count is', count)

which creates this:

Note that this code follows Streamlit’s unique functional style and captures the counter state embedded in the component. How did we achieve this? Happily, a single function call, declare_component, does all the work to enable bidirectional communication with Streamlit.

# Declare a simple counter component.
import streamlit.components.v1 as components
counter = components.declare_component("counter", path=BUILD_PATH)

Nice! Under the hood, BUILD_PATH points to a component built using React, Vue, or any frontend technology you like. For this example we decided to use React and Typescript giving us this render function:

and this callback:

Donezo! You’ve now created a simple, stateful component which “feels like React” on the website, and “feels like Streamlit” on the Python side. Information is passed back to Python using Streamlit.setComponentValue(...). Because we’re using React in this case, the component’s state is stored in this.state. For more details on this example, see our component template.

A neat benefit of this architecture is that you’re not limited to React. You can use any language or framework which compiles for the web. Here is the same counter component written in ClojureScript.

Another cool feature of this API is that you can do hot-reloading as you develop your component like this:

components.declare_component(name, url="http://localhost:3001")      

Here, the url parameter lets you specify a dev server for the component created with npm run start.

What we’ve shown you so far just scratches the surface. For more details, please check our documentation.

Sharing with the world

Did you create something broadly useful for the Streamlit community? Sure, you could keep that superpower for yourself, but it would be even cooler to share it! Get community feedback and praise. 😇 You can easily wrap your component in a PyPi package and submit it to our Gallery by following these instructions.

Try it out and let us know what you think!

We’re excited to unlock for the community a new way to plug-and-play functionality into Streamlit. Streamlit Components let you write simple HTML extensions or tap into the whole ecosystem provided by React, Vue, and other frameworks. Your feedback drives innovation in Streamlit. Please tell us what you think and what you’d like next. Show off your shiny new components and share them with the world. We can’t wait to see what you build! 🎈

Special thanks to Fanilo Andrianasolo, Daniel Haziza, Synode, and the entire Streamlit Components beta community who helped refine this architecture and inspired us with their feedback and ideas. Thanks also to TC Ricks, Amanda Kelly, Thiago Teixeira, Beverly Treuille, Regan Carey, and Cullan Carey for their input on this article.

Introducing Streamlit Components was originally published in Streamlit on Medium, where people are continuing the conversation by highlighting and responding to this story.

In 2018, we began building the tools to visualize Python scripts that became Streamlit. By then, Python was the preeminent language of machine learning, bristling with powerful libraries like Keras and OpenCV. Python made it easy to analyze rich datasets and train detailed models. However, our decade of machine learning work at Carnegie Mellon, Google, and Zoox had shown us the difficulty of extending these newfound powers throughout an organization. We wanted to share models and insights with coworkers. We wanted to build custom tools that made machine learning repeatable, shareable, modifiable, and usable throughout an organization. We wanted to show off our work in beautiful apps that let others use what we had created.

Last Fall, after a year of development, we released Streamlit, an open-source framework to turn Python scripts into interactive apps. The response exceeded our greatest expectations. Streamlit has been downloaded over 400,000 times and is now democratizing data-driven decision making across virtually every industry, from tech giants like Google and Uber to Delta Dental, 7–11, and even the NBA! Over 200,000 Streamlit apps have been created, and every day we see the Streamlit community share apps to predict COVID rates, visualize new chemical compounds, analyze music playlists, recommend movies, and much, much more. We are awed, inspired, and delighted daily by the community’s creativity.

Today we are excited to announce a $21 million Series A investment into Streamlit, co-led by GGV Capital and Gradient Ventures, and with participation from Bloomberg Beta, Elad Gil, Daniel Gross, and few other amazing investors.

This investment will enable us to develop new superpowers for the Streamlit community. Our goal is to make Streamlit not only the most productive (and fun!) app-building experience in Python, but also the most powerful. We’ll be introducing new ways to extend apps, including releases for custom layout and programmable state. The investment will also accelerate the development of Streamlit for Teams, our forthcoming paid offering for deploying, securing, and sharing Streamlit apps, that includes a free tier for public Github repos. It’s currently in closed beta, and we’ll be expanding the beta soon! Thank you for your patience, and if you haven’t signed up yet, click here.

Thank you for trying, using, and loving Streamlit. The apps you create, articles you share, and messages you send make us eager to come to work every day and build Streamlit into an even more amazing tool for everyone. We’re excited to start this new chapter with you and to see what we can build together. Let’s start creating! 🎈

Adrien Treuille, Amanda Kelly, and Thiago Teixeira
- Streamlit Co-founders

Announcing Streamlit’s $21M Series A was originally published in Streamlit on Medium, where people are continuing the conversation by highlighting and responding to this story.

We’ll show you how to quickly build a Streamlit app to synthesize celebrity faces using GANs, Tensorflow, and st.cache.

Machine learning models are black boxes. Yes, you can run them on test sets and plot fancy performance curves, but it’s still often hard to answer basic questions about how they perform. A surprisingly powerful source of insight is simply to play with your models! Tweak inputs. Watch outputs. Let your coworkers and managers play with them too. This interactive approach is not only a powerful way to gain intuition, but also a great way to get people excited about your work.

Making interactive models is one of the use-cases that inspired Streamlit, a Python framework that makes writing apps as easy as writing Python scripts. This overview will walk you through creating a Streamlit app to play with one of the hairiest and black-box-iest models out there: a deep Generative Adversarial Network (GAN). In this case, we’ll visualize Nvidia’s PG-GAN [1] using TensorFlow to synthesize photorealistic human faces from thin air. Then, using Shaobo Guan’s amazing TL-GAN model [2], we’ll create an app that gives us the ability to tweak GAN-synthesized celebrity faces by attributes like age, smileyness, male likeness, and hair color. By the end of the tutorial, you’ll have a fully parametric model of humans! (Note we didn’t create the attributes. They came from the CelebA dataset [3], and some of them can get a bit weird…)

Getting started with Streamlit

If you haven’t installed Streamlit yet, you can do so by running:

pip install streamlit
streamlit hello

And if you’re a seasoned Streamlit-er, you’ll need to be on 0.57.1 or later, so make sure to upgrade!

pip install --upgrade streamlit

Setting up your environment

Before we begin, use the commands below to check out the project’s GitHub repo and running the Face GAN demo for yourself. This demo depends on Tensorflow 1, which does not support Python 3.7 or 3.8, so you’ll need Python 3.6. On Mac and Linux, we recommend using pyenv to install Python 3.6 alongside your current version, then setting up a new virtual environment using venv or virtualenv. On Windows, the Anaconda Navigator allows you to pick your Python version with a point-and-click interface.

When you’re all set, open a terminal window and type:

git clone https://github.com/streamlit/demo-face-gan.git
cd demo-face-gan
pip install -r requirements.txt
streamlit run app.py

Give it a minute to finish downloading the trained GAN and then try playing with the sliders to explore the different faces the GAN can synthesize. Pretty cool, right?

The full app code is a file that has ~190 lines of code, out of which only 13 are Streamlit calls. That’s right, the entire UI above is drawn from just those 13 lines!

Let’s take a look at how the app is structured:

Now that you have a sense of how it is structured, let’s dive into each of the 5 steps above to see how they work.

Step 1. Download models and data files

This step downloads the files we need: a pre-trained PG-GAN model and a TL-GAN model pre-fitted to it (we’ll dive into these a little bit later!).

The download_file utility function is a little smarter than a pure downloader:

• It checks if the file is already present in the local directory, so it only downloads it if needed. It also checks if the downloaded file’s size is what we expected it to be, so it’s able to fix interrupted downloads. This is a great pattern to follow!

• It uses st.progress() and st.warning() to show a nice UI to the user while the file downloads. Then it calls .empty() on those UI elements to hide them when done.

Step 2. Load the models into memory

The next step is to load these models into memory. Here is the code for loading the PG-GAN model:

Notice the @st.cache decorator at the start of load_pg_gan_model(). Normally in Python, you could just run load_pg_gan_model() and reuse that variable over and over. Streamlit’s execution model is unique, however, in that every time a user interacts with a UI widget your script executes again in its entirety, from top to bottom. By adding @st.cache to the costly model-loading functions, we are telling Streamlit to only run those functions the first time the script executes — and just reuse the cache output for every execution after that. That is one of Streamlit’s most fundamental features, as it lets you run scripts efficiently by caching the results of function calls. This way, the large fitted GAN models will be loaded into memory exactly once; and by the same token, our TensorFlow session will be created exactly once, as well. (See our launch article for a refresher on Streamlit’s execution model.)

There’s one wrinkle, though: the TensorFlow session object can mutate internally as we use it to run different computations. Ordinarily, we don’t want cached objects to mutate, as that can lead to unexpected results. So when Streamlit detects such mutations, it issues a warning to the user. However, in this case we happen to know that it’s OK if the TensorFlow session object mutates, so we bypass the warning by setting allow_output_mutation=True.

Step 3. Draw the sidebar UI

If this is the first time you’re seeing Streamlit’s API for drawing widgets, here’s the 30-second crash course:

• You add widgets by calling API methods like st.slider() and st.checkbox().
• The return value of those methods is the value shown in the UI. For example, when the user moves a slider to position 42, your script will be re-executed and in that execution the return value of that st.slider() will be 42.
• You can put anything in a sidebar by prepending it with st.sidebar. For example, st.sidebar.checkbox().

So to add a slider in the sidebar, for example — a slider to allow the user to tune the brown_hair parameter, you would just add:

In our app we want to get a little fancy to show off just how easy it is to make the UI itself modifiable in Streamlit! We want to allows users to first use a multiselect widget to pick a set of features they want to control in the generated image, which means our UI needs to be drawn programmatically:

With Streamlit, the code for that is actually quite simple:

Step 4. Synthesize the image

Now that we have a set of features telling us what kind of face to synthesize, we need to do the heavy lifting of synthesizing the face. The way we’ll do that is by passing the features into the TL-GAN to generate a vector in the PG-GAN’s latent space, then feed that vector to PG-GAN. If that sentence made no sense to you, let’s take a detour and talk about how our two neural nets work.

A detour into GANs

To understand how the above app generates faces from slider values, you first have to understand something about how PG-GAN and TL-GAN work — but don’t worry, you can skip this section and still understand how the app works at a higher level!

PG-GAN, like any GAN, is fundamentally a pair of neural networks, one generative and one discriminative, which are trained against each other, forever locked in mortal combat. The generative network is in charge of synthesizing images it believes look like faces, and the discriminative network is in charge of deciding whether or not the images are indeed faces. The two networks are iteratively trained against each other’s output, so each one does its best to learn to fool the other network. The end result is the final generative network is able to synthesize realistic-looking faces even though at the start of training all it could synthesize was random noise. Its really quite amazing! In this case, the face-generating GAN we use was trained on celebrity faces by Karras et al using their Progressive Growing of GANs algorithm (PG-GAN), which trains GANs using progressively higher-resolution images. [1]

The input to PG-GAN is a high-dimensional vector belonging to its so-called latent-space. The latent-space is basically the space of all possible faces the network can generate, so each random vector in that space corresponds to a unique face (or at least it should! Sometimes you get weird results…) The way you typically use a GAN is to give it a random vector and then check out what face gets synthesized (Figure 2.a).

However, that sounds a bit dull and we’d rather have some more control over the output. We’d like to tell PG-GAN “generate an image of a man with a beard”, or “generate an image of a brown-haired woman”. That’s where the TL-GAN comes in.

The TL-GAN is yet another neural network, this one trained by entering random vectors into PG-GAN, taking the generated faces, and running them through classifiers for attributes like “is young-looking”, “is bearded”, “is brown-haired”, etc. In the training phase, TL-GAN labels thousands of faces from PG-GAN with those classifiers and identifies directions in the latent space that correspond to changes in the labels we care about. As a result, the TL-GAN learns how to map those classes (i.e. “young-looking”, “bearded”, “brown-haired”) into the appropriate random-looking vector that should be input into PG-GAN to generate a face with those characteristics (Figure 2.b).

Going back to our app, at this point we’ve already downloaded the pre-trained GAN models and loaded them into memory, and we’ve also grabbed a feature vector from the UI. So now we just have to feed those features into TL-GAN and then PG-GAN to get an image out:

Optimize performance

The generate_image() function above can take some time to execute, especially when running on a CPU. To improve our app’s performance it would be great if we could cache the output of that function, so we don’t have to re-synthesize faces we’ve already seen as we move the slider back and forth.

Well, as you may have noticed in the snippet above already, the solution here is to once again use the @st.cache decorator.

But notice the two arguments we passed to @st.cache in this case: show_spinner=False and hash_funcs={tf.Session: id}. What are those there for?

The first one is easy to explain: by default, @st.cache shows a status box in the UI letting you know that a slow-running function is currently executing. We call that a “spinner”. However, in this case, we’d like to avoid showing it, so the UI doesn’t jump around unexpectedly. So we set show_spinner to False.

The next one solves a more involved problem: the TensorFlow session object, which is passed as an argument to generate_image(), is usually mutated by TensorFlow’s internals in between runs of this cached function. This means the input arguments to generate_image() will always be different and we’ll never actually get a cache hit. In other words, the @st.cache decorator won’t actually do anything! How can we solve this?

Hash_funcs to the rescue

The hash_funcs option allows us to specify custom hash functions that tell @st.cache how it should interpret different objects when checking whether this is a cache hit or a cache miss. In this case, we’re going to use that option to tell Streamlit to hash a TensorFlow session by calling Python’s id() function rather than by examining its contents:

This works for us because the session object in our case is actually a singleton across all executions of the underlying code since it comes from the @st.cache’d load_pg_gan_model() function.

For more information about hash_funcs, check out our documentation about advanced caching techniques.

Step 5. Draw the synthesized image

Now that we have the output image, drawing it is a piece of cake! Just call Streamlit’s st.image function:

st.image(image_out, use_column_width=True)

And we’re done!

Wrapping up

So there you have it: interactive face synthesis with TensorFlow in a 190-line Streamlit app and only 13 Streamlit function calls! Have fun exploring the space of faces these two GANs can draw, and many thanks to Nvidia and Shaobo Guan for letting us build off their super cool demos. We hope that you have as much fun building apps and playing with models as we do. 🎈

For more Streamlit app examples, you can check out our gallery at https://www.streamlit.io/gallery.

Thanks to Ash Blum, TC Ricks, Amanda Kelly, Thiago Teixeira, Jonathan Rhone and Tim Conkling for their helpful input on this article.

References:

[1] T. Karras, T. Aila, S. Laine, J. Lehtinen. Progressive Growing of GANs for Improved Quality, Stability, and Variation. International Conference on Learning Representations (ICLR 2018)

[2] S. Guan. Controlled image synthesis and editing using a novel TL-GAN model. Insight Data Science Blog (2018)

[3] Z. Liu, P. Luo, X. Wang, X. Tang. Deep Learning Face Attributes in the Wild. International Conference on Computer Vision (ICCV 2015)

Build an app to synthesize photorealistic faces using TensorFlow and Streamlit was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

In my experience, every nontrivial machine learning project is eventually stitched together with bug-ridden and unmaintainable internal tools. These tools — often a patchwork of Jupyter Notebooks and Flask apps — are difficult to deploy, require reasoning about client-server architecture, and don’t integrate well with machine learning constructs like Tensorflow GPU sessions.

I saw this first at Carnegie Mellon, then at Berkeley, Google X, and finally while building autonomous robots at Zoox. These tools were often born as little Jupyter notebooks: the sensor calibration tool, the simulation comparison app, the LIDAR alignment app, the scenario replay tool, and so on.

As a tool grew in importance, project managers stepped in. Processes sprouted. Requirements flowered. These solo projects gestated into scripts, and matured into gangly maintenance nightmares.

When a tool became crucial, we called in the tools team. They wrote fluent Vue and React. They blinged their laptops with stickers about declarative frameworks. They had a design process:

Which was awesome. But these tools all needed new features, like weekly. And the tools team was supporting ten other projects. They would say, “we’ll update your tool again in two months.”

So we were back to building our own tools, deploying Flask apps, writing HTML, CSS, and JavaScript, and trying to version control everything from notebooks to stylesheets. So my old Google X friend, Thiago Teixeira, and I began thinking about the following question: What if we could make building tools as easy as writing Python scripts?

We wanted machine learning engineers to be able to create beautiful apps without needing a tools team. These internal tools should arise as a natural byproduct of the ML workflow. Writing such tools should feel like training a neural net or performing an ad-hoc analysis in Jupyter! At the same time, we wanted to preserve all of the flexibility of a powerful app framework. We wanted to create beautiful, performant tools that engineers could show off. Basically, we wanted this:

With an amazing beta community including engineers from Uber, Twitter, Stitch Fix, and Dropbox, we worked for a year to create Streamlit, a completely free and open source app framework for ML engineers. With each prototype, the core principles of Streamlit became simpler and purer. They are:

#1: Embrace Python scripting. Streamlit apps are really just scripts that run from top to bottom. There’s no hidden state. You can factor your code with function calls. If you know how to write Python scripts, you can write Streamlit apps. For example, this is how you write to the screen:

import streamlit as st

st.write('Hello, world!')

#2: Treat widgets as variables. There are no callbacks in Streamlit! Every interaction simply reruns the script from top to bottom. This approach leads to really clean code:

import streamlit as st

x = st.slider('x')
st.write(x, 'squared is', x * x)

#3: Reuse data and computation. What if you download lots of data or perform complex computation? The key is to safely reuse information across runs. Streamlit introduces a cache primitive that behaves like a persistent, immutable-by-default, data store that lets Streamlit apps safely and effortlessly reuse information. For example, this code downloads data only once from the Udacity Self-driving car project, yielding a simple, fast app:

In short, Streamlit works like this:

1. The entire script is run from scratch for each user interaction.
2. Streamlit assigns each variable an up-to-date value given widget states.
3. Caching allows Streamlit to skip redundant data fetches and computation.

Or in pictures:

If this sounds intriguing, you can try it right now! Just run:

$ pip install --upgrade streamlit 
$ streamlit hello

   You can now view your Streamlit app in your browser.

   Local URL: http://localhost:8501
   Network URL: http://10.0.1.29:8501

This will automatically pop open a web browser pointing to your local Streamlit app. If not, just click the link.

Ok. Are you back from playing with fractals? Those can be mesmerizing.

The simplicity of these ideas does not prevent you from creating incredibly rich and useful apps with Streamlit. During my time at Zoox and Google X, I watched as self-driving car projects ballooned into gigabytes of visual data, which needed to be searched and understood, including running models on images to compare performance. Every self-driving car project I’ve seen eventually has had entire teams working on this tooling.

Building such a tool in Streamlit is easy. This Streamlit demo lets you perform semantic search across the entire Udacity self-driving car photo dataset, visualize human-annotated ground truth labels, and run a complete neural net (YOLO) in real time from within the app [1].

The whole app is a completely self-contained, 300-line Python script, most of which is machine learning code. In fact, there are only 23 Streamlit calls in the whole app. You can run it yourself right now!

$ pip install --upgrade streamlit opencv-python
$ streamlit run
https://raw.githubusercontent.com/streamlit/demo-self-driving/master/app.py

As we worked with machine learning teams on their own projects, we came to realize that these simple ideas yield a number of important benefits:

Streamlit apps are pure Python files. So you can use your favorite editor and debugger with Streamlit.

Pure Python scripts work seamlessly with Git and other source control software, including commits, pull requests, issues, and comments. Because Streamlit’s underlying language is pure Python, you get all the benefits of these amazing collaboration tools for free 🎉.

Streamlit provides an immediate-mode live coding environment. Just click Always rerun when Streamlit detects a source file change.

Caching simplifies setting up computation pipelines. Amazingly, chaining cached functions automatically creates efficient computation pipelines! Consider this code adapted from our Udacity demo:

Basically, the pipeline is load_metadata → create_summary. Every time the script is run Streamlit only recomputes whatever subset of the pipeline is required to get the right answer. Cool!

Streamlit is built for GPUs. Streamlit allows direct access to machine-level primitives like TensorFlow and PyTorch and complements these libraries. For example in this demo, Streamlit’s cache stores the entire NVIDIA celebrity face GAN [2]. This approach enables nearly instantaneous inference as the user updates sliders.

Streamlit is a free and open-source library rather than a proprietary web app. You can serve Streamlit apps on-prem without contacting us. You can even run Streamlit locally on a laptop without an Internet connection! Furthermore, existing projects can adopt Streamlit incrementally.

This just scratches the surface of what you can do with Streamlit. One of the most exciting aspects of Streamlit is how these primitives can be easily composed into complex apps that look like scripts. There’s a lot more we could say about how our architecture works and the features we have planned, but we’ll save that for future posts.

We’re excited to finally share Streamlit with the community today and see what you all build with it. We hope that you’ll find it easy and delightful to turn your Python scripts into beautiful ML apps.

Thanks to Amanda Kelly, Thiago Teixeira, TC Ricks, Seth Weidman, Regan Carey, Beverly Treuille, Geneviève Wachtell, and Barney Pell for their helpful input on this article.

References:

[1] J. Redmon and A. Farhadi, YOLOv3: An Incremental Improvement (2018), arXiv.

[2] T. Karras, T. Aila, S. Laine, and J. Lehtinen, Progressive Growing of GANs for Improved Quality, Stability, and Variation (2018), ICLR.

[3] S. Guan, Controlled image synthesis and editing using a novel TL-GAN model (2018), Insight Data Science Blog.

Turn Python Scripts into Beautiful ML Tools was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.