Cómo ejecutar Jupiter, Keras, Tensorflow y otras bibliotecas de ML en Docker

Este artículo continuará la serie de artículos relacionados con Docker y mostrará cómo crear un contenedor Docker basado en Ubuntu 20.04 LTS para aprendizaje automático. Instalaremos en el entorno:Python 3, Jupyter, Keras, Tensorflow, TensorBoard, Pandas, Sklearn, Matplotlib, Seaborn, pyyaml, h5py. ¡Prepare su entorno de ML personal en 3 minutos, sin incluir el tiempo de creación de imágenes de Docker!

Actualización 2020

Actualicé el contenedor a la base Ubuntu 20.04 LTS y aceleré el proceso de compilación de Docker. Ahora no estamos compilando OpenCV desde la fuente, sino instalándolo desde apt .

La configuración del entorno es una pregunta común cuando comienza a aprender Machine Learning (ML). En este artículo, le mostraré cómo crear su propio contenedor Docker, incluidos los siguientes marcos para un comienzo cómodo:

• Python 3
• Jupyter
• Keras
• Flujo de tensor
• TensorTablero
• Pandas
• Sklearn
• Matplotlib
• Nacido del mar
• pyyaml
• h5py

Esos son los TOP 10 marcos de Python ampliamente utilizados para la ciencia de datos, y encontrará la mayoría de ellos en cualquier artículo de instrucciones en Internet. En el siguiente artículo (Cómo crear un contenedor de Python Data Science Docker basado en Anaconda), mostraré cómo crear la misma imagen sobre la distribución de Anaconda.

Requisitos

Todo lo que necesita es Docker y el editor de texto instalados en su sistema.

Estructura del Proyecto

Aquí está la estructura final del proyecto:

$ tree -a python_data_science_container

$ python_data_science_container
├── Dockerfile
├── conf
│   └── .jupyter
│       └── jupyter_notebook_config.py
└── run_jupyter.sh

2 directories, 3 files

Dockerfile

Todo lo que necesita hacer es crear una carpeta de proyecto y un nombre de archivo Dockerfile dentro:

$ mkdir python_data_science_container

$ cd python_data_science_container

$ vim Dockerfile

Después de eso, coloque el siguiente contenido en Dockerfile :

FROM ubuntu:20.04
MAINTAINER "Andrei Maksimov"

ENV DEBIAN_FRONTEND noninteractive

RUN apt-get update && apt-get install -y \
	libopencv-dev \
        python3-pip \
	python3-opencv && \
    rm -rf /var/lib/apt/lists/*

RUN pip3 install tensorflow && \
    pip3 install numpy \
        pandas \
        sklearn \
        matplotlib \
        seaborn \
        jupyter \
        pyyaml \
        h5py && \
    pip3 install keras --no-deps && \
    pip3 install opencv-python && \
    pip3 install imutils

RUN ["mkdir", "notebooks"]
COPY conf/.jupyter /root/.jupyter
COPY run_jupyter.sh /

# Jupyter and Tensorboard ports
EXPOSE 8888 6006

# Store notebooks in this mounted directory
VOLUME /notebooks

CMD ["/run_jupyter.sh"]

Siempre puede encontrar ejemplos actualizados de mi propio Dockerfile en GitHub, que utilizo para crear mi entorno de contenedor de ciencia de datos personal (también está disponible en Docker Hub de forma gratuita).

Configuración de Jupyter

Tan pronto como declaramos nuestro contenedor y sus componentes, es hora de preparar una configuración para Jupyter. Cree un archivo jupyter_notebook_config.py con el siguiente contenido:

# get the config object
c = get_config()
# in-line figure when using Matplotlib
c.IPKernelApp.pylab = 'inline'
c.NotebookApp.ip = '*'
c.NotebookApp.allow_remote_access = True
# do not open a browser window by default when using notebooks
c.NotebookApp.open_browser = False
# No token. Always use jupyter over ssh tunnel
c.NotebookApp.token = ''
c.NotebookApp.notebook_dir = '/notebooks'
# Allow to run Jupyter from root user inside Docker container
c.NotebookApp.allow_root = True

Como puede adivinar de Dockerfile , lo pondremos en /root/.jupyter/ carpeta durante el proceso de creación del contenedor.

Creando script de inicio

Lo último que debemos hacer es crear un script run_jupyter.sh , que lanzará el servidor de Júpiter dentro de nuestro contenedor durante su proceso de inicio. Crea una con el siguiente contenido:

#!/usr/bin/env bash

jupyter notebook "$@"

Y haz que este archivo sea ejecutable:

$ chmod +x run_jupyter.sh

Este archivo se iniciará dentro de su contenedor de forma predeterminada cada vez que inicie uno nuevo.

Creando imagen de contenedor

La última etapa:creación de contenedores. Simplemente ejecute el siguiente comando para construir su contenedor Docker desde el directorio del proyecto:

$ docker build -f Dockerfile -t python_data_science_container .

Docker instalará todas las bibliotecas y marcos necesarios dentro de la imagen de su contenedor durante el proceso de compilación y lo pondrá a disposición para su uso.

Contenedor en ejecución

Ahora tiene un contenedor de trabajo y es hora de iniciarlo. Cree una carpeta dentro de la carpeta de su proyecto donde almacenaremos todos nuestros Jupyter Notebooks con el código fuente de nuestros proyectos:

$ mkdir notebooks

E inicie el contenedor con el siguiente comando:

$ docker run -it -p 8888:8888 \
    -p 6006:6006 \
    -d \
    -v $(pwd)/notebooks:/notebooks \
    python_data_science_container

Iniciará el contenedor y expondrá Jupyter en el puerto 8888 y Tensorflow Dashboard en el puerto 6006 en su computadora local o su servidor, según dónde haya ejecutado este comando.

Tenga en cuenta que este contenedor se creó solo con fines de desarrollo local. yo Se eliminó la autenticación en Jupyter en este contenedor, por lo que todos pueden conectarse al puerto 8888 o 6006 y ejecutar el código de causa de Python.

Si solo está buscando una solución que funcione

Si no desea crear y mantener su propio contenedor y los componentes mencionados anteriormente son suficientes para usted, no dude en utilizar mi contenedor personal, que suelo actualizar:

$ docker run -it -p 8888:8888 \
    -p 6006:6006 \
    -d \
    -v $(pwd)/notebooks:/notebooks \
    amaksimov/python_data_science

Espero que este artículo te sea útil. Si te gusta el artículo, vuelve a publicarlo usando cualquier red social que desees. ¡Hasta pronto!