Come eseguire Jupiter, Keras, Tensorflow e altre librerie ML in Docker

Questo articolo continuerà la serie di articoli relativi a Docker e mostrerà come creare un contenitore Docker basato su Ubuntu 20.04 LTS per Machine Learning. Installeremo nell'ambiente:Python 3, Jupyter, Keras, Tensorflow, TensorBoard, Pandas, Sklearn, Matplotlib, Seaborn, pyyaml, h5py. Prepara il tuo ambiente ML personale in 3 minuti, escluso il tempo di creazione dell'immagine Docker!

Aggiornamento 2020

Ho aggiornato il contenitore alla base di Ubuntu 20.04 LTS e ho accelerato il processo di compilazione di Docker. Ora non stiamo costruendo OpenCV dal sorgente ma installiamolo da apt .

La configurazione dell'ambiente è una domanda comune quando si inizia ad apprendere Machine Learning (ML). In questo articolo, ti mostrerò come creare il tuo container Docker, inclusi i seguenti framework per un comodo inizio:

• Pitone 3
• Giove
• Kera
• flusso tensoriale
• Tavola Tensor
• Panda
• Sklearn
• Matplotlib
• Nata dal mare
• pyyaml
• h5py

Questi sono i TOP 10 framework Python ampiamente utilizzati per la scienza dei dati e ne troverai la maggior parte in qualsiasi articolo su Internet. Nel prossimo articolo (Come costruire un container Python Data Science Docker basato su Anaconda), mostrerò come costruire la stessa immagine sopra la distribuzione Anaconda.

Requisiti

Tutto ciò che devi avere è Docker e editor di testo installati sul tuo sistema.

Struttura del progetto

Ecco la struttura finale del progetto:

$ tree -a python_data_science_container

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

2 directories, 3 files

File Docker

Tutto quello che devi fare è creare una cartella di progetto e un nome file Dockerfile dentro:

$ mkdir python_data_science_container

$ cd python_data_science_container

$ vim Dockerfile

Successivamente, inserisci i seguenti contenuti in 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"]

Puoi sempre trovare esempi aggiornati del mio Dockerfile su GitHub, che utilizzo per creare il mio ambiente container Data Science personale (è disponibile anche su Docker Hub gratuitamente).

Configurazione di Jupyter

Non appena abbiamo dichiarato il nostro container e i suoi componenti, è il momento di preparare una configurazione per Jupyter. Crea un file jupyter_notebook_config.py con il seguente contenuto:

# 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

Come puoi intuire da Dockerfile , lo inseriremo in /root/.jupyter/ cartella durante il processo di creazione del contenitore.

Creazione dello script di avvio

L'ultima cosa che dobbiamo fare è creare uno script run_jupyter.sh , che avvierà il server Jupiter all'interno del nostro container durante il processo di avvio. Crea una con il seguente contenuto:

#!/usr/bin/env bash

jupyter notebook "$@"

E rendi questo file eseguibile:

$ chmod +x run_jupyter.sh

Questo file verrà avviato all'interno del tuo contenitore per impostazione predefinita ogni volta che ne avvierai uno nuovo.

Creazione dell'immagine del contenitore

L'ultima fase:la creazione del contenitore. Basta eseguire il comando seguente per creare il tuo contenitore Docker dalla directory del progetto:

$ docker build -f Dockerfile -t python_data_science_container .

Docker installerà tutte le librerie e i framework necessari all'interno dell'immagine del contenitore durante il processo di compilazione e la renderà disponibile per l'uso.

Contenitore in esecuzione

Ora hai un container funzionante ed è ora di avviarlo. Crea una cartella all'interno della cartella del tuo progetto dove memorizzeremo tutti i nostri Jupyter Notebook con il codice sorgente dei nostri progetti:

$ mkdir notebooks

E avvia il contenitore con il seguente comando:

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

Avvierà il container ed esporrà Jupyter alla porta 8888 e Tensorflow Dashboard sulla porta 6006 sul tuo computer locale o sul tuo server, a seconda di dove hai eseguito questo comando.

Tieni presente che questo contenitore è stato creato solo per scopi di sviluppo locale. io rimossa l'autenticazione su Jupyter in questo contenitore, in modo che tutti possano connettersi alla porta 8888 o 6006 ed eseguire il codice di causa Python.

Se stai solo cercando una soluzione funzionante

Se non vuoi creare e mantenere il tuo container e i suddetti componenti ti saranno sufficienti, sentiti libero di usare il mio container personale, che di solito aggiorno:

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

Spero che questo articolo ti sia utile. Se ti piace l'articolo, ripubblicalo utilizzando qualsiasi social media che desideri. A presto!