Turn a Jupyter Notebook into a Web App

#python #datascience #tutorial #webdev

Let’s say you’re a data scientist, and you’ve been asked to solve a problem. Of course, what you really want is to build an interactive tool, so your colleagues can solve the problem themselves!

In this tutorial, I'll show you how to take a machine-learning model in a Jupyter notebook, and turn it into a web application using the Anvil Uplink.

Here's what we'll do:

Set up a Jupyter notebook
Connect it to an Anvil app
Make a user interface

Setting up the Jupyter Notebook

We'll start with a pre-existing Jupyter Notebook containing a classification model that distinguishes between cats and dogs. You give it an image and it scores it as ‘cat’ or ‘dog’.

(Thanks to Uysim Ty for sharing it on Kaggle.)

Connecting to the Uplink

We'll use the Anvil Uplink to connect a Jupyter Notebook to Anvil. It’s a library you can pip install on your computer or wherever your Notebook is running.

It allows you to:

call functions in your Jupyter Notebook from your Anvil app
call functions in your Anvil app from your Juypter Notebook - store data in your Anvil app from your Jupyter Notebook
use the Anvil server library inside your Jupyter Notebook

It works for any Python process - this happens to be a Jupyter Notebook, but it could be an ordinary Python script, a Flask app, even the Python REPL!

To connect our notebook, we'll first need to enable the Uplink in the Anvil IDE.

This gives us a key that we can then use in our code.

We then need to pip install the Uplink library on the machine the Jupyter Notebook is running on:

pip install anvil-uplink

By adding the following lines to our Jupyter notebook, we can connect it to our Anvil app:

import anvil.server

anvil.server.connect('<YOUR-UPLINK-KEY>')

Now we can do anything in our Jupyter Notebook that we can do in an Anvil Server Module - call Anvil server functions, store data in Data Tables, and define server functions to be called from other parts of the app.

Loading an image into the Notebook

We'll load an image into the Jupyter Notebook by making an anvil.server.callable function in the Jupyter Notebook. It will classify the input image as either a cat or a dog.

import anvil.media

@anvil.server.callable
def classify_image(file):
   with anvil.media.TempFile(file) as filename:
      img = load_img(filename)

We’re passing the image in as an Anvil Media object, which we then write to a temporary file.

The load_img function loads the file into Pillow, a Python imaging library.

Then we can do a bit of post-processing of the image to get it into a format that the model likes:

    # Inside the classify_image function

    img = img.resize((128, 128), resample=PIL.Image.BICUBIC)
    arr = img_to_array(img)
    arr = np.expand_dims(arr, axis=0)
    arr /= 255

Then we can just pass it into our model and return the result:

    # Inside the classify_image function

    score = model.predict(arr)
    return ('dog' if score < 0.5 else 'cat', float(score))

Building a User Interface

We can drag-and-drop components to create a User Interface. It consists of a FileLoader to upload the images, an Image to display them, and a Label to display the classification.

Making the UI call the Notebook

Now we need to write some Python code that runs in the browser so the app responds when an image is loaded in.

We can define an event handler that triggers when the FileLoader gets a new file:

  def file_loader_1_change(self, file, **event_args):
    """This method is called when a new file is loaded into this FileLoader."""
    result, score = anvil.server.call('classify_image', file)

    self.result_lbl.text = "%s (%0.2f)" % (result, score)
    self.image_1.source = file

The first line calls the classify_image function in the Jupyter Notebook, passing in the image file.

Then we display the result (cat or dog) and the score (0 to 1; completely dog or completely cat).

We also put the image file into the Image component so that the user can see their cat or dog (or other cat-or-dog-like image) and decide if they agree with the result.