Créer un environnement Docker qui peut utiliser PyTorch et JupyterLab

Construction de l'environnement PyTorch + JupyterLab Docker

Nous avons construit un environnement Docker qui peut utiliser PyTorch, qui devient populaire en tant que cadre d'apprentissage en profondeur, et Jupyter Lab (successeur de Jupyter Notebook), qui est populaire lors de l'utilisation de Python pour l'analyse de données. Nous avons créé un nouvel environnement, nous allons donc réviser l'article (2019.12.14)

Flux de travail

  1. Installez le pilote de carte graphique NVIDIA GPU et NVIDIA Container Toolkit
  2. Modifiez le fichier Docker de JupyterLab pour créer une image Docker
  3. Apportez le PyTorch GitHub officiel
  4. Apportez les modifications nécessaires au fichier Docker officiel de PyTorch, par exemple en le spécifiant en fonction de l'image Docker créée en 2.
  5. Créer l'image Docker de PyTorch

Procédure spécifique

Installer le pilote NVIDIA et la boîte à outils NVIDIA Container

J'ai fait référence à cet article. J'avais l'habitude d'installer le pilote de la carte graphique et CUDA, cudnn directement sur une machine Linux, mais j'ai eu du mal car cela ne fonctionnait pas bien si la combinaison du framework Deep Learning et de chaque version était différente. Je pense que c'est devenu beaucoup plus facile que ça.

Installation du pilote graphique NVIDIA

Enregistrez le référentiel de pilotes avec apt.

$ sudo add-apt-repository ppa:graphics-drivers/ppa
$ sudo apt update

Installez le pilote recommandé.

$ sudo apt -y install ubuntu-drivers-common
$ sudo ubuntu-drivers autoinstall

Installez la boîte à outils NVIDIA Container

Installez le NVIDIA Container Toolkit, qui comprend les temps d'exécution requis pour utiliser le GPU de NVIDIA avec Docker. Tout d'abord, enregistrez le référentiel avec apt.

$ curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
$ curl -s -L https://nvidia.github.io/nvidia-docker/$(. /etc/os-release;echo $ID$VERSION_ID)/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
$ sudo apt update

Ensuite, installez la boîte à outils.

$ sudo apt -y install nvidia-container-toolkit

Redémarrez la machine une fois.

$ sudo shutdown -r now

Après cela, vous pouvez vérifier si le GPU est reconnu par la commande ci-dessous.

$ nvidia-container-cli info

Obtenez le Dockerfile qui est la base de JupyterLab

Clonez GitHub de Jupter pour obtenir le fichier Docker de base.

$ git clone https://github.com/jupyter/docker-stacks.git

--Fichier à utiliser - base-notebook/Dockerfile

Apportez des modifications au Dockerfile sur lequel Jupyter Lab est basé

base-Changez la base lors de la construction du notebook / Dockerfile pour devenir le Docker de NVIDIA. La ligne # est désactivée dans la description d'origine en mettant en commentaire, et les lignes suivantes sont activées. J'ai ouvert le bloc-notes de base / Dockerfile avec un éditeur de texte et j'ai changé la description au début comme suit. Veuillez vous référer à la page Docker Hub de NVIDIA et sélectionnez la version qui convient au framework Deep Learning que vous souhaitez utiliser.

 #ARG BASE_CONTAINER=ubuntu:bionic-20191029@sha256:6e9f67fa63b0323e9a1e587fd71c561ba48a034504fb804fd26fd8800039835d
 #FROM $BASE_CONTAINER
 FROM nvidia/cuda:10.0-cudnn7-devel-ubuntu16.04

Construire le Dockerfile de base

Créez une image Docker dans le répertoire base-notebook avec une commande comme celle ci-dessous. Vous pouvez nommer librement l'image Docker après -t.

$ docker image build ./ -t experiments/base-notebook

Affichez l'image Docker avec la commande suivante et vérifiez si elle a été créée.

$ docker images

Créez une image Docker PyTorch basée sur l'image Docker de Jupyter Lab.

Clonez le PyTorch GitHub officiel avec une commande comme celle ci-dessous dans le répertoire que vous souhaitez enregistrer.

$ git clone https://github.com/pytorch/pytorch.git

Apporter des modifications au Dockerfile de PyTorch

Copiez docker / pytorch / Dockerfile en tant que docker / pytorch-notebook / Dockerfile et apportez les modifications nécessaires. Ouvrez / pytorch-notebook / Dockerfile avec un éditeur de texte et modifiez le début pour qu'il soit basé sur l'image Docker de Jupyter Lab créée à l'étape précédente.

#FROM nvidia/cuda:10.0-cudnn7-devel-ubuntu16.04
FROM experiments/base-notebook:latest

Il y a un endroit pour installer miniconda (version légère d'Anaconda) avant d'installer PyTorch, Comme il est installé par Docker de Jupyer Lab, il est désactivé en commentant, et il est exécuté à partir de l'endroit où d'autres bibliothèques et pytorch sont installés. Préfixez la ligne que vous souhaitez activer avec RUN. Il est ajouté pour exécuter le programme de tutoriel de PyTorch et installer les packages suivants.

 # Install PyTorch
 #RUN curl -o ~/miniconda.sh -O  https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh  && \
 #     chmod +x ~/miniconda.sh && \
 #     ~/miniconda.sh -b -p /opt/conda && \
 #     rm ~/miniconda.sh && \
 RUN  /opt/conda/bin/conda install -y python=$PYTHON_VERSION numpy pyyaml scipy ipython mkl mkl-include ninja cython typing \
    ipykernel pandas matplotlib scikit-learn pillow seaborn tqdm openpyxl ipywidgets && \
    /opt/conda/bin/conda install -y -c pytorch magma-cuda100 && \
    /opt/conda/bin/conda install -y -c conda-forge opencv pyside2 && \
    /opt/conda/bin/conda clean -ya
ENV PATH /opt/conda/bin:$PATH

Post-scriptum: J'ai eu l'erreur suivante lors de l'importation d'opencv. "Erreur d'importation: libGL.so.1: impossible d'ouvrir le fichier d'objet partagé: aucun fichier ou répertoire de ce type" J'ai ajouté "libgl1-mesa-dev" où j'ai fait l'installation d'apt-get. (Reportez-vous à cet article)

J'ai commenté la description ci-dessous pour correspondre à l'environnement utilisateur JupyterLab Docker. WORKDIR /workspace RUN chmod -R a+w . Au lieu de cela, j'ai ajouté la description ci-dessous.

    RUN chown -R $NB_UID:$NB_GID /home/$NB_USER
    WORKDIR /home/$NB_USER
    # Switch back to jovyan to avoid accidental container runs as root
    USER $NB_UID
    RUN echo 'export PATH=/opt/conda/bin:$PATH'>> ~/.bashrc

Créer une image Docker pour PyTorch

Le "répertoire racine" </ font> de PyTorch cloné à partir de GitHub (veuillez noter qu'il est assez facile de faire une erreur. Il a été décidé de mettre à jour le sous-module depuis GitHub, cmake, etc. (Doit être en position), créez une image Docker avec une commande comme celle ci-dessous. Dans cet exemple, le nom de l'image Docker à créer est affiché sous la forme "experiences / pytorch-notebook".


$ docker build -t experiments/pytorch-notebook -f docker/pytorch-notebook/Dockerfile .

Notez que le processus cmake pour caffe2 prend un temps considérable.

Utiliser l'image Docker créée

Créez un conteneur à partir de l'image Docker créée et exécutez-le. Définissez le mot de passe pour accéder pour la première fois à Jupyter Lab avec un navigateur. J'ai fait référence à cet article.

docker run \
 --rm -it \
 --user root \
 --name pytorch-notebook \
 experiments/pytorch-notebook:latest \
 /bin/bash -c \
 "python -c 'from notebook.auth import passwd;print(passwd())'"

Vous serez invité à entrer le mot de passe, alors entrez-le deux fois. La valeur du mot de passe haché (sha1: xxxxxxxxxxxxxxxxxxxxxxxx) sera sortie, alors enregistrez-la.

Enter password:
Verify password:
sha1:xxxxxxxxxxxxxxxxxxxxxxxx

Démarrez Jupyter Lab avec un mot de passe haché (spécifié dans --NotebookApp.password =).

docker run \
 --rm \
 --user root -e NB_UID=$UID \
 -p 58888:8888 -p 50022:22 -p 56006:6006 \
 -v ~/:/home/jovyan/work \
 --name pytorch-notebook \
 --gpus all \
 --ipc=host \
 experiments/pytorch-notebook:latest \
 start.sh jupyter lab --NotebookApp.password="sha1:xxxxxxxxxxxxxxxxxxxxxxxx"

Vous pouvez utiliser Jupyter Lab en accédant à localhost: 58888 (lorsque les numéros de port sont mappés comme dans l'exemple ci-dessus) avec un navigateur Web.

Lorsque vous utilisez GPU avec PyTorch, il semble que vous deviez allouer de la mémoire avec des options telles que --ipc = host ou --shm-size = 16G. Si vous définissez num_workers sur 1 ou plus dans le chargeur de données lors de la création d'un mini-lot et utilisez le multi-processus, il semble que cela soit causé par l'échange de données utilisant la mémoire partagée. [Article de référence Qiita](https://qiita.com/sakaia/items/671c843966133cd8e63c#docker%E3%81%A7%E3%81%AEdataloader%E5%88%A9%E7%94%A8%E3%81 % AE% E6% B3% A8% E6% 84% 8F)

Si vous souhaitez exécuter un fichier python, utilisez% run.

%run -i sample.py

References [1] PyTorch GitHub [2] Jupyte Lab Dockerfile [3] Utilisation du GPU dans Docker Container avec NVIDIA Container Toolkit [4] Création d'un environnement pour Jupyter Lab avec Docker

Recommended Posts

Créer un environnement Docker qui peut utiliser PyTorch et JupyterLab
Flutter dans Docker - Comment créer et utiliser un environnement de développement Flutter dans un conteneur Docker
Créer un environnement go à l'aide de Docker
Image Docker pouvant utiliser cx_Oracle
[DynamoDB] [Docker] Créer un environnement de développement pour DynamoDB et Django avec docker-compose
[Linux] Créer un environnement Jenkins avec Docker
Utiliser WebDAV dans un environnement Docker portable
[Linux] Construction de l'environnement Docker avec Amazon Linux 2
Créez un environnement CentOS Linux 8 avec Docker et démarrez Apache HTTP Server
Créez un environnement virtuel Python que tout le monde peut comprendre Septembre 2016 (pyenv + virutalenv)
Créez un environnement LAMP sur votre Docker local
[Python] Créer un environnement de développement Django avec Docker
Créez un environnement virtuel avec pyenv et venv
[Docker] Créez un environnement jupyterLab (python) en 3 minutes!
Construisez un environnement Python + bouteille + MySQL avec Docker sur RaspberryPi3! [Essai et erreur]
Créer un environnement d'analyse de données qui relie l'authentification GitHub et Django avec JupyterHub
Création d'un environnement de travail Docker R et Python
Créez un environnement virtuel python avec virtualenv et virtualenvwrapper
Comment créer un environnement Django (python) sur Docker
[Go + Gin] J'ai essayé de créer un environnement Docker
Créez un environnement virtuel python avec virtualenv et virtualenvwrapper
Créez un conteneur Docker et enregistrez le png depuis altair
Créez un environnement de développement avec Poetry Django Docker Pycharm
Créer un environnement de développement d'API rapide léger à l'aide de Docker
Construire un environnement de calcul numérique avec pyenv et miniconda3
[Django] Créez rapidement un environnement de développement de conteneur Django (Docker) à l'aide de VS Code + Remote Containers
Comment utiliser Docker pour conteneuriser votre application et comment utiliser Docker Compose pour exécuter votre application dans un environnement de développement
Créez un environnement d'apprentissage automatique scikit-learn avec VirtualBox et Ubuntu
[Memo] Construire un environnement de développement pour Django + Nuxt.js avec Docker
Configurer un environnement de test automatique du navigateur qui peut exécuter Selenium + Pytest avec Docker Compose
Créer un environnement LAMP [CentOS 7]
[Django] Créez rapidement un environnement de développement de conteneur Django (Docker) avec PyCharm
Créons un environnement Docker qui stocke les informations de tendance Qiita!
Créer un environnement Python et transférer des données vers le serveur
Créer un environnement d'apprentissage automatique
Créez un environnement GPU avec GCP et l'image officielle de Kaggle (docker)
Créer une application Todo avec Django ① Créer un environnement avec Docker
Créer un environnement Python hors ligne
Créez un environnement de développement Flask à faible coût avec Docker
Mettez Jupyter et Docker Compose dans votre Chromebook et utilisez-le comme un environnement de développement léger!
Remarques sur la création d'un environnement LAMP à l'aide de Vagrant et VirtulBox
Créer un environnement Chainer à l'aide de CUDA et cuDNN sur une instance p2
Création de l'environnement de travail Docker R et Python 2: prise en charge du japonais
Créer et tester un environnement CI pour plusieurs versions de Python
Créez un environnement Python 2.7 64 bits avec TDM-GCC et MinGW-w64 sous Windows 7
Créez un environnement Python sur votre Mac avec Anaconda et PyCharm
Essayez d'utiliser virtualenv qui peut créer un environnement virtuel de Python
Créez et essayez un environnement OpenCV et Python en quelques minutes à l'aide de Docker
Apprenez à utiliser Docker en créant un environnement pour Django + MySQL
Créer un fichier deb avec Docker
Construire un environnement Mysql + Python avec docker
[Note] Construction et utilisation du noyau WSL2
Créer un environnement python3 sur CentOS7
J'ai essayé de créer un environnement capable d'acquérir, de stocker et d'analyser les données de tweet en WSL (bash)
Créer un environnement de développement à l'aide de Jupyter et Flask avec Python dans Docker (prend en charge à la fois VS Code / code-server)