Google Colaboratory est un service cloud récemment lancé visant à simplifier la recherche en apprentissage automatique et en apprentissage profond. En utilisant le Colaboratory, vous pouvez accéder à distance à une machine avec une carte vidéo connectée, et c'est entièrement gratuit, ce qui simplifie considérablement la vie lorsque vous devez former des réseaux de neurones profonds. Nous pouvons dire qu'il s'agit d'un analogue des documents Google pour le bloc-notes Jupyter.
Colaboratory a préinstallé Tensorflow et presque toutes les bibliothèques Python nécessaires pour travailler. Si un paquet est manquant, il est facilement installé sur le pouce via
pip ou
apt-get . Mais que se passe-t-il si vous devez créer un projet à partir de la source et vous connecter au GPU? Il s'avère que cela peut ne pas être si simple que je l'ai découvert lors de la construction de
SSD-Caffe . Dans cette publication, je donnerai une brève description du Colaboratoire, décrirai les difficultés rencontrées et comment les résoudre, ainsi que quelques astuces utiles.
Tout le code est disponible dans mon
carnet de colaboratoire .
En bref sur le colaboratoire
En gros, Colaboratory vous permet d'exécuter Jupyter Notebook sur une machine distante. Les fichiers de collaboration sont des "ordinateurs portables" .ipynb ordinaires et sont stockés sur le disque Google. Il existe également un ensemble de fonctions qui vous permettent de télécharger des fichiers depuis une machine distante vers le disque Google et vice versa. Vous pouvez également partager ces fichiers avec d'autres, vous pouvez y écrire des commentaires, comme dans les documents Google.
Dans le Colaboratory, vous pouvez utiliser le GPU, à savoir le Tesla K80. Pour ce faire, connectez-le dans les paramètres: Runtime
Modifier le type d'exécution
Accélérateur matériel. Il convient de noter que les GPU ne sont pas toujours disponibles, puis le Colaboratory proposera de démarrer la machine sans elle.
Il semble que rien ne puisse démarrer sauf le Jupyter Notebook lui-même, mais il y a un accès indirect au terminal: pour cela, vous devez ajouter un point d'exclamation devant la commande du terminal, par exemple
!mkdir images . En général, nous pouvons supposer que nous avons affaire à une machine ordinaire parfaite sur laquelle Ubuntu 17.10 est installé (au moment de la rédaction), mais connecté à distance. Il s'ensuit que tout ce qui peut être fait via le terminal (pas de manière interactive) peut être fait sur celui-ci, y compris:
- cloner des référentiels à l'aide de
git clone , - charger des données à l'aide de
wget (d'ailleurs, même les gros fichiers sont chargés presque instantanément à partir d'un disque Google), - utilisez
make (et probablement cmake ) - installer des outils et des bibliothèques en utilisant
apt-get et pip
Quelques commentaires supplémentaires sur le Colaboratoire:
- Il semble que l'utilisateur ait un accès illimité à tous les fichiers du système (toutes les commandes doivent être écrites sans
sudo ); - L'état terminal n'est pas transféré entre les équipes, même si elles sont dans la même cellule (par exemple,
cd dir si nécessaire, vous devrez écrire au début de chaque commande); - Si vous vous déconnectez du Colaboratory pendant une longue période, toutes les modifications de la machine virtuelle seront effacées, y compris tous les packages installés et les fichiers téléchargés.Par conséquent, il est recommandé que l'installation des packages soit incluse dans le bloc-notes Jupyter;
- Après 12 heures d'utilisation continue, la machine s'éteint automatiquement, mais elle peut ensuite être redémarrée (en théorie, dans la pratique, le GPU peut ne pas être disponible).
Construction SSD-Caffe
Je voulais essayer le
Single Shot Detector (SSD) , à savoir son
implémentation Caffe dans Google Colaboratory, mais pour cela, le projet devait être assemblé à partir de la source.
Soit dit en passant, si une version de
Caffe vous convient, il existe un moyen beaucoup plus simple (cela fonctionne même, bien que je n'aie rien essayé):
!apt install caffe-cuda
Assembler SSD-Caffe à partir de la source est une quête assez longue en plusieurs étapes, qui ne peut être effectuée qu'avec des béquilles.
Étape 1: installation des dépendancesIci, nous devons télécharger toutes les dépendances pour Caffe en utilisant
apt . Cependant, avant de faire cela, vous devez autoriser
apt à télécharger le code source des dépendances.
Le guide d'installation de Caffe indique que cela nécessite une «ligne deb-src dans le fichier sources.list». Malheureusement, il n'y a aucun détail là-bas, donc je viens de décommenter toutes les lignes
deb-src dans le fichier
/etc/apt/sources.list :
with open('/etc/apt/sources.list') as f: txt = f.read() with open('/etc/apt/sources.list', 'w') as f: f.write(txt.replace('# deb-src','deb-src'))
Et ça a marché. Il ne reste plus qu'à télécharger les dépendances:
!apt update !apt build-dep caffe-cuda
Étape 2: besoin d'un autre compilateurIci, le problème est le suivant:
g++-7 , qui est la valeur par défaut, est pour une raison quelconque incompatible avec le compilateur
nvcc CUDA, vous devez donc utiliser autre chose. J'ai téléchargé
g++-5 et en ai fait le compilateur par défaut:
!apt install g++-5 !update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-5 20 !update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-5 20
Étape 3: avoir à construire un boostSi vous essayez de construire Caffe à ce stade, des problèmes surviendront lorsque vous essayez de connecter boost, car il a été construit par un autre compilateur, vous devez donc télécharger ses sources et également construire en utilisant
g++-5 (
plus sur le site web de boost ):
!wget https://dl.bintray.com/boostorg/release/1.67.0/source/boost_1_67_0.tar.bz2 !tar --bzip2 -xf boost_1_67_0.tar.bz2 !cd boost_1_67_0 && ./bootstrap.sh --exec-prefix=/usr/local --with-libraries=system,filesystem,regex,thread,python --with-python-version=2.7 --with-python-root=/usr !cd boost_1_67_0 && ./b2 install
Étape 4: Configurer le MakefileClone Caffe avec GitHub:
!git clone https://github.com/weiliu89/caffe.git && cd caffe && git checkout ssd
Et nous changeons les champs nécessaires dans Makefile.config - J'ai changé le chemin d'accès à CUDA, changé l'option BLAS, changé la version d'OpenCV en une troisième, ajouté une couche Python et ajouté également tous les chemins d'accès aux bibliothèques qui ont été installées, mais pour une raison quelconque, ils n'ont pas été trouvés (tout cela est pratique) fait en utilisant Python):
with open('caffe/Makefile.config.example') as f: config = f.read() comment = ['CUDA_DIR := /usr/local/cuda', 'BLAS := open'] uncomment = ['# CUDA_DIR := /usr', '# BLAS := atlas', '# OPENCV_VERSION := 3', '# WITH_PYTHON_LAYER := 1']
De plus, dans le Makefile lui-même, j'ai dû remplacer toutes les balises
-isystem par
-I : les deux sont responsables de la recherche des en-têtes, mais ils sont traités un peu différemment, et sans ce remplacement, des problèmes se sont déjà produits lorsque stdlib était connecté (
plus de détails ici ):
with open('caffe/Makefile') as f: mfile = f.read() with open('caffe/Makefile', 'w') as f: f.write(mfile.replace('-isystem','-I'))
Étape 5: ConstruireIl restait une dernière béquille - pour corriger le
c++config.h , sinon il y a des problèmes avec les types nan (
plus ):
with open('/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h') as f: txt = f.read() with open('/usr/include/x86_64-linux-gnu/c++/5/bits/c++config.h', 'w') as f: f.write(txt.replace('/* #undef _GLIBCXX_USE_C99_MATH */', '/* #undef _GLIBCXX_USE_C99_MATH */\n#define _GLIBCXX_USE_C99_MATH 1'))
Maintenant, en fait, vous pouvez construire Caffe:
!cd caffe && make -j8 && make pycaffe && make test -j8 && make distribute !echo /usr/local/lib >> /etc/ld.so.conf && ldconfig !echo /content/caffe/distribute/lib >> /etc/ld.so.conf && ldconfig
Les deux dernières lignes ajoutent les chemins de bibliothèque, à savoir boost et Caffe.
Maintenant, Caffe peut être utilisé (il vous suffit de spécifier le chemin d'accès à celui-ci dans PYTHONPATH):
import sys caffe_path = !cd caffe/python && pwd sys.path.insert(0, caffe_path[0]) import caffe
Pour le tester, j'ai testé le projet
Mobilenet-SSD : le code est également dans mon
carnet de colaboratoire .
En particulier, j'ai mesuré le temps de prédiction pour une image, et l'accélération sur le GPU était d'environ 3,8.
Bonus: quelques astuces utiles
Il existe un
excellent tutoriel sur Medium sur Google Colaboratory. Dans le Colaboratory même, il y a des fichiers avec des exemples de presque tout ce qui peut être nécessaire.
Montez un disque Google dans le système de fichiers d'une machine virtuelle:
!apt-get install -y -qq software-properties-common python-software-properties module-init-tools !add-apt-repository -y ppa:alessandro-strada/ppa 2>&1 > /dev/null !apt-get update -qq 2>&1 > /dev/null !apt-get -y install -qq google-drive-ocamlfuse fuse from google.colab import auth auth.authenticate_user() from oauth2client.client import GoogleCredentials creds = GoogleCredentials.get_application_default() import getpass !google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret} < /dev/null 2>&1 | grep URL vcode = getpass.getpass() !echo {vcode} | google-drive-ocamlfuse -headless -id={creds.client_id} -secret={creds.client_secret}
Ce code renverra le lien et donnera une fenêtre d'entrée. Vous devez suivre le lien, copier le code et le saisir dans la fenêtre. Pour une raison quelconque, je dois le faire deux fois. Suivant:
!mkdir -p drive !google-drive-ocamlfuse drive
Après cela, vous pouvez utiliser votre disque Google comme répertoire normal. De plus, toutes les modifications de ce répertoire sont automatiquement synchronisées avec Google Drive.
Installation de
Keras :
!pip install -q keras import keras
Installez
PyTorch :
from os import path from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag()) accelerator = 'cu80' if path.exists('/opt/bin/nvidia-smi') else 'cpu' !pip install -q http://download.pytorch.org/whl/{accelerator}/torch-0.3.0.post4-{platform}-linux_x86_64.whl torchvision import torch
Changer le répertoire de travail:
import os os.chdir("/path/to/wdir")
Effacez toutes les modifications et redémarrez la machine:
!kill -9 -1
Téléchargez le fichier sur la machine locale:
from google.colab import files files.download('file.ext')
Obtenez le dictionnaire des fichiers téléchargés sur le disque Google:
from google.colab import files uploaded = files.upload()
Couper la sortie de la commande du terminal (rediriger vers la variable):
lines_list = !pwd
En général, Google Colaboratory offre une bonne occasion de mener une formation sur les réseaux de neurones dans le cloud. Certes, cela peut ne pas être suffisant pour les très grandes grilles. Un autre avantage est la possibilité d'exécuter du code indépendamment du système d'exploitation local (ce qui est bon pour la reproductibilité), et également de travailler ensemble sur le même projet. En guise de hic, le GPU peut ne pas être disponible, y compris pendant longtemps.