Containerizing Deep Learning Applications with Docker: A Comprehensive Guide

In the rapidly evolving landscape of software development, containers have emerged as the de facto standard for developing and deploying applications. With tools like Docker and Kubernetes leading the charge, this trend is particularly pronounced in the realm of machine learning. The flexibility that containers offer—allowing developers to experiment with various frameworks, versions, and hardware configurations with minimal overhead—has made them indispensable. Moreover, containers eliminate discrepancies between development and production environments, are lighter than traditional virtual machines, and can be easily scaled up or down to meet demand.

In this article, we will delve into the process of containerizing a deep learning application using Docker. Our application consists of a TensorFlow model for image segmentation, a Flask web framework, uWSGI for serving, and Nginx for load balancing. If you haven’t followed the previous articles in this series, I highly recommend checking them out for a more comprehensive understanding.

Our ultimate goal is to deploy this model in the cloud and scale it to accommodate millions of users. So, let’s get started!

What is a Container?

A container is a standardized unit of software that packages code and all its dependencies, ensuring that the application runs quickly and reliably across different computing environments. This means that you can run the same software in any environment, regardless of the underlying operating system or hardware.

Containers solve common issues such as missing dependencies, facilitate collaboration among developers, and provide isolation from other applications. They also eliminate the age-old excuse: “It works on my machine; I don’t understand why it doesn’t work here.”

Unlike virtual machines, which replicate the entire operating system, containers run on top of the host operating system’s kernel, making them significantly lighter and more portable.

What is Docker?

Docker has gained immense popularity over the years, to the point where it has become synonymous with containers. Docker is an open-source platform that provides a service for building, deploying, and managing containerized applications. It comes with a powerful Command Line Interface (CLI), a user-friendly desktop interface (Docker Desktop), and access to thousands of ready-to-use container images via Docker Hub.

Let’s dive into using Docker for our deep learning application!

How to Set Up Docker

The first step is to install the Docker engine on your machine. For detailed instructions, I recommend visiting the official Docker documentation. Once you have Docker installed, you can verify it by running the following command in your terminal:

$ docker run ubuntu

This command spins up a container using a minimal Ubuntu image. If you want to enter the container, you can run:

$ docker run -it ubuntu

This will give you a bash terminal inside the container, allowing you to execute commands as if you were on a regular system.

How to Build a Deep Learning Docker Image

Now that we have Docker set up, it’s time to build our TensorFlow/Flask/uWSGI image that contains our UNet model. Before we start, we need to identify the necessary dependencies. If you’ve been developing your application inside a virtual environment, you can generate a requirements.txt file with:

$ pip freeze > requirements.txt

This file will list all the installed libraries along with their versions. For our application, we will include:

Flask==1.1.2
uWSGI==2.0.18
Tensorflow==2.2.0

Next, we need to restructure our application so that all necessary code resides in a single folder. Here’s how our folder structure should look:

app/
  ├── unet/
  ├── app.ini
  ├── requirements.txt
  ├── service.py
  └── unet_inferrer.py

Writing the Dockerfile

The Dockerfile is a script that contains all the commands to assemble an image. Here’s a simple Dockerfile for our application:

FROM tensorflow/tensorflow:2.0.0

WORKDIR /app

ADD . /app

RUN pip install -r requirements.txt

CMD ["uwsgi", "app.ini"]

This Dockerfile does the following:

1. FROM: Specifies the base image (in this case, TensorFlow).
2. WORKDIR: Sets the working directory inside the container.
3. ADD: Copies the local files into the container.
4. RUN: Installs the required Python libraries.
5. CMD: Specifies the command to run when the container starts.

To build the image, run:

$ docker build -t deep-learning-production:1.0 .

This command may take some time, especially since the TensorFlow image is quite large. Once the build is complete, you should see a success message.

How to Run a Deep Learning Docker Container

Now that we have our image, it’s time to run the container:

$ docker run --publish 80:8080 --name dlp deep-learning-production:1.0

This command publishes the container’s port 8080 to port 80 on your local machine. If everything goes well, you should see logs indicating that the uWSGI server has started.

Setting Up an Nginx Container

Next, we’ll set up an Nginx container to act as a reverse proxy in front of the uWSGI server. The Nginx configuration file (nginx.conf) should look something like this:

server {
  listen 80;
  location / {
    include uwsgi_params;
    uwsgi_pass app:660;
  }
}

The corresponding Dockerfile for Nginx will be simple:

FROM nginx

RUN rm /etc/nginx/conf.d/default.conf

COPY nginx.conf /etc/nginx/conf.d/

Using Docker Compose

To manage multiple containers, we can use Docker Compose. This tool allows us to define and run multi-container Docker applications. Create a docker-compose.yml file with the following content:

version: "3.7"
services:
  app:
    build: ./app
    container_name: deep-learning-production
    restart: always
    expose:
      - 660
  nginx:
    build: ./nginx
    container_name: nginx
    restart: always
    ports:
      - "80:80"

To build and start the containers, run:

$ docker-compose up

Now, you can test your application by sending requests to the Nginx server, which will route them to the uWSGI server.

Conclusion

By following the steps outlined in this article, you have successfully containerized a deep learning application using Docker. This process has provided you with a fully isolated environment that includes all necessary dependencies, allowing for easy deployment and scalability.

In the next articles, we will explore how to deploy this application in the cloud and utilize Kubernetes for orchestration, monitoring, and scaling to serve millions of users.

Stay tuned for more insights into the world of machine learning and cloud computing!

References

• Deep Learning in Production Book
• Docker Documentation
• Kubernetes Documentation

Disclosure: Some links above might be affiliate links, and at no additional cost to you, we may earn a commission if you decide to make a purchase after clicking through.