Résumé de l'image Jupyter Docker

Il s'agit d'une version mise à jour de l'article suivant. L'image est organisée car Jupyter a été mis à niveau vers la série 5.

• Essayez d'utiliser l'image Docker de Jupyter --Qiita

Jupyter a commencé avec IPython, un outil pour Python, mais comme le processus d'analyse des données peut être partagé sur le Web, il a également été utilisé dans R, et récemment il a été intégré à Spark avec l'infrastructure Hadoop comme back-end. est. Comme représenté par Numpy et pandas, les bibliothèques requises pour l'analyse des données peuvent avoir des dépendances compliquées et peuvent être difficiles à installer, mais Docker peut améliorer la portabilité de l'environnement d'exécution. De plus, comme l'environnement d'exécution peut être séparé pour chaque conteneur, le mécanisme d'exécution de Docker sur Hadoop ([Docker Container Executor --Apache Hadoop 2.7.4](https://hadoop.apache.org/docs/stable/hadoop-yarn] /hadoop-yarn-site/DockerContainerExecutor.html)) est également à l'étude (même si je pense que c'est un peu tôt dans la phase pratique). On pense que ce sera une direction pour utiliser correctement les images légères en fonction du but, je vais donc résumer les images organisées par Jupyter.

Le serveur Jupyter est destiné à une utilisation par un seul utilisateur. Par conséquent, un seul type de mot de passe peut être défini. Veuillez utiliser JupyterHub pour plusieurs personnes.

Liste des images Docker

L'image Jupyter Docker est gérée séparément comme suit. GitHub a un référentiel * jupyter / docker-stacks *, mais Docker Hub a plusieurs images.

La relation entre chaque image est facile à comprendre dans le diagramme Visual Overview (ʻinternal / inherit-diagram.png`) dans le référentiel GitHub.

• jupyter/docker-stacks: Opinionated stacks of ready-to-run Jupyter applications in Docker.

Comme les paramètres de démarrage sont gérés par le script shell de base-notebook, il est recommandé de lire le README de "Base Jupyter Notebook Stack" pour les options et ainsi de suite.

• docker-stacks/base-notebook

[off topic] Avec Toree et Spylon, vous pouvez écrire des blocs-notes qui utilisent Spark dans Scala. Cependant, le statut du projet va de alpha à bêta, vous devez donc faire attention à la version que vous utilisez lorsque vous l'utilisez. Si vous ne vous souciez pas de Jupyter et que vous souhaitez configurer un notebook qui utilise Spark, Apache Zeppelin est également une bonne option.

Utilisez * base-notebook *

Essayez d'utiliser * base-notebook *. Je ne pense pas qu'il fonctionnera réellement avec cette image, mais comme il s'agit d'une image d'environ 600 Mo, elle est juste pour démarrer rapidement.

Tout d'abord, téléchargez l'image avec la commande pull.

$ docker pull jupyter/base-notebook
$ docker images jupyter/base-notebook
REPOSITORY              TAG                 IMAGE ID            CREATED             SIZE
jupyter/base-notebook   latest              749eef0adf19        4 days ago          599MB

Démarrez le conteneur sur le port par défaut 8888. Lorsqu'il démarre normalement, le jeton d'authentification sera affiché sur la console. Copiez l'URL et accédez-y avec un navigateur. Vous pouvez accéder à l'interface utilisateur Web sans jeton et entrer une valeur après * token = * dans la zone de saisie.

$ docker run -it --rm -p 8888:8888 jupyter/base-notebook
(réduction)
    
    Copy/paste this URL into your browser when you connect for the first time,
    to login with a token:
        http://localhost:8888/?token=1898d7309d85940ac77acc59b15b4f9c572c96afdfc0e198

Ensuite, pour exécuter en arrière-plan, exécutez avec différentes options. Dans ce cas, rien ne s'affiche dans la sortie standard après l'exécution de la commande. Vous aurez besoin d'un jeton d'authentification pour accéder à votre notebook, utilisez donc la commande * logs * pour vérifier les journaux de démarrage. Pour l'argument, spécifiez le nom défini au démarrage du conteneur.

$ docker run -d --name basenb -p 8888:8888 jupyter/base-notebook
$ docker logs basenb

Il y a un problème en raison du fait qu'il est difficile de lire l'affichage du journal ultérieurement. Vous pouvez également utiliser la commande jupyter pour renvoyer une liste de serveurs en cours d'exécution, de sorte que vous pouvez obtenir une sortie claire en accédant au conteneur avec la commande * exec * et en exécutant la jupyter notebook list.

$ docker exec basenb jupyter notebook list
Currently running servers:
http://localhost:8888/?token=1898d7309d85940ac77acc59b15b4f9c572c96afdfc0e198 :: /home/jovyan

Jeton d'authentification et mot de passe

La sécurité du serveur de notebook Jupyter se trouve dans les documents suivants:

• Security in the Jupyter notebook server

Il existe deux méthodes, l'une consiste à utiliser un jeton d'authentification et l'autre à utiliser un mot de passe. Les jetons d'authentification peuvent être donnés dans l'en-tête HTTP * Authorization * ou dans le paramètre * token * de l'URL. Par défaut, la méthode d'utilisation du jeton d'authentification est activée, et on peut dire que la méthode donnée par le paramètre * token * de l'URL est affichée dans le message de démarrage.

Le comportement d'activation des jetons d'authentification par défaut a été introduit depuis Jupyter 4.3. Cependant, il semble que la publication n'ait pas été complètement organisée, et il existe de nombreux malentendus lors de la combinaison de plusieurs options.

• Security release: Jupyter Notebook 4.3.1
• Make token URL clearer when no-browser is given · Issue #1980 · jupyter/notebook
• Run notebook without requesting for stupid token · Issue #2254 · jupyter/notebook

Si votre ordinateur local ouvre automatiquement le navigateur au démarrage, vous pouvez accéder à l'URL avec un jeton temporaire et enregistrer les informations auxquelles vous pouvez y accéder dans un cookie afin de pouvoir l'utiliser de manière transparente. Cependant, lors du démarrage depuis Docker ou depuis un serveur distant, le démarrage automatique du navigateur est désactivé, il faut donc beaucoup de travail pour l'authentification.

Le jeton d'authentification et le mot de passe peuvent être spécifiés comme options de démarrage.

---- NotebookApp.token: Spécifiez une chaîne fixe au lieu de la génération automatique par défaut. La valeur définie n'est pas sortie dans le journal au démarrage.

---- NotebookApp.password: l'authentification par mot de passe est utilisée sans utiliser le jeton d'authentification dans l'URL et l'en-tête. La chaîne de mot de passe est hachée avec la fonction notebook.auth.passwd.

En principe, vous pouvez désactiver la fonction d'authentification en spécifiant un blanc pour les deux, mais cette méthode est * fortement déconseillée * sauf si vous restreignez l'accès à d'autres couches de votre application Web.

[off topic] Le traitement des options de configuration est implémenté dans notebook / notebookapp.py, donc la relation entre les options est le code source. Est précis à lire. L'implémentation utilise Traitlets, c'est donc une bonne idée d'ouvrir la référence pendant la lecture.

La fonction notebook.auth.passwd est simplement importée et appelée sans argument. Entrez le mot de passe que vous souhaitez spécifier et ressaisissez-le pour confirmation. Sort le résultat haché.

Pour l'enregistrer en tant que fichier de configuration, exécutez jupyter notebook password ou python -m notebook.auth password. Le premier est meilleur. Entrez le mot de passe que vous voulez exécuter et définissez deux fois et le fichier de paramètres sera enregistré dans .jupyter / jupyter_notebook_config.json. Si vous le conservez sous forme de fichier, vous pouvez le gérer en montant le fichier sur la machine hôte à partir du conteneur Docker. Le fichier de configuration peut également être géré par Python.

$ docker exec -it basenb jupyter notebook password
$ docker exec -it basenb cat .jupyter/jupyter_notebook_config.json
{
  "NotebookApp": {
    "password": "sha1:2165e2ddd92d:8131245514d60dd9eb91433af30bf1ccbbc36962"
  }
}

Ici, redémarrez le conteneur pour refléter le contenu du fichier de paramètres. Lorsque vous rechargez le navigateur, une zone de texte pour saisir le mot de passe s'affiche, alors assurez-vous que vous pouvez vous connecter avec le mot de passe défini ci-dessus.

$ docker stop basenb
$ docker start basenb

De plus, comme le jeton d'authentification n'existe plus, l'URL avec le jeton n'est pas sortie dans le journal et le jeton n'est pas affiché même avec la commande jupyter notebook list. Cela nous a permis de passer du jeton d'authentification par défaut à l'authentification par mot de passe.

Configuration par option de démarrage à partir de la commande docker

Dans certains environnements, il ne convient pas de vérifier le journal ou de monter le fichier à chaque démarrage. Dans de tels cas, donnez un jeton d'authentification ou un hachage de mot de passe dans les options de démarrage.

Utilisez start-notebook.sh lors du démarrage du conteneur et spécifiez les options ci-dessus.

Lors de l'attribution d'un jeton d'authentification:

$ docker run -d --name basenb-token -p 8080:8888 jupyter/base-notebook start-notebook.sh --NotebookApp.token=foobarbaz

Lorsque vous donnez un hachage de mot de passe:

$ docker run -d --name basenb-passwd -p 8088:8888 jupyter/base-notebook start-notebook.sh --NotebookApp.password=sha1:2165e2ddd92d:8131245514d60dd9eb91433af30bf1ccbbc36962

Si vous souhaitez donner à la fois un jeton d'authentification et un hachage de mot de passe, exécutez avec les deux options.

En gros, il est préférable de gérer avec un mot de passe, mais si vous souhaitez l'exécuter dans un environnement cloud et le partager facilement uniquement avec une URL, la méthode du jeton d'authentification est également bonne. Cependant, veuillez suivre la politique de sécurité de l'environnement utilisateur pour les restrictions sur l'adresse IP de la source d'accès.

Pour les autres paramètres SSL, reportez-vous aux documents suivants.

• Running a notebook server

Utilisez * scipy-notebook *

Maintenant que nous avons organisé les problèmes de démarrage, dessinons un graphique en utilisant une autre image Docker.

Téléchargez l'image * scipy-notebook * et vérifiez la capacité.

$ docker pull jupyter/scipy-notebook
$ docker images jupyter/scipy-notebook
REPOSITORY               TAG                 IMAGE ID            CREATED             SIZE
jupyter/scipy-notebook   latest              092599e85093        5 days ago          3.91GB

Commencez en arrière-plan et vérifiez le jeton.

$ docker run -d --name scipynb -p 8888:8888 jupyter/scipy-notebook
$ docker exec scipynb jupyter notebook list

Accédez au serveur de notebook avec un navigateur Web et créez un nouveau notebook Python 3.

Tout d'abord, exécutez le chargement du module standard comme indiqué ci-dessous.

Chargement du module Python

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
%matplotlib inline

Ensuite, générez les données sinus et cosinus pour la fonction triangulaire.

sin/Définition de cos

import math
cycle = math.pi * 2
x = np.linspace(-1 * cycle, cycle, 100)
y1 = np.sin(x)
y2 = np.cos(x)

Dessinons avec l'API matplotlib. Spécifiez deux séries de données, donnez des noms aux axes X et Y et donnez un titre au graphique. Si vous souhaitez utiliser le japonais, placez le fichier de police dans le conteneur. [^ 1]

[^ 1]: reportez-vous à cet article pour savoir comment définir l'axe du graphique en japonais. Paramètres japonais pour les axes matplotlib et Seaborn - Qiita

Dessiner avec l'API matplotlib

sns.set_style('whitegrid')
plt.plot(x, y1, color='red', linewidth=2, label='sin')
plt.plot(x, y2, color='blue', linewidth=1, label='cos')
plt.xlabel('x axis')
plt.ylabel('y axis')
plt.title('sin/cos curve')
plt.legend()
plt.show()

Dessinez la même chose avec l'API pandas DataFrame. Le graphique lui-même est facile, mais la valeur de retour matplotlib.AxesSubplot est utilisée pour les paramètres d'axe et ainsi de suite. De plus, pour faciliter la compréhension de la différence avec le graphique ci-dessus, Seaborn a changé le style pour des bordures plus sombres.

Dessiner avec l'API DataFrame

df = pd.DataFrame({'sin': y1, 'cos': y2}, index=x)
sns.set_style('darkgrid')
ax = df.plot(title='sin/cos curve')
ax.set_xlabel('x axis')
ax.set_ylabel('y axis')

Ensuite, dessinons un graphique boursier en utilisant Bokeh. Les données sur le cours des actions sont obtenues auprès de Yahoo! À l'aide de * pandas-datareader *. * pandas-datareader * est indépendant du package * pandas.io *.

Utilisez pip pour installer le module. Préfixez la commande avec un "!" Pour exécuter la commande à partir du notebook.

Installer le module à l'aide de pip

!pip install -y pandas-datareader

Obtenez les données en spécifiant la date.

Obtenez des données avec l'API

import datetime
import pandas_datareader.data as web

start = datetime.date(2014, 4, 1)
end = datetime.date.today()

stocks = web.DataReader("^N225", 'yahoo', start, end)
stocks.head(5)

Activez Bokeh sur votre ordinateur portable.

Activer le bokeh

import bokeh.plotting as bplt
bplt.output_notebook()

Dessinez un graphique. Bokeh utilise JavaScript pour effectuer le rendu dans un navigateur, vous pouvez donc utiliser le japonais sans avoir à mettre une police japonaise du côté du conteneur.

Dessinez un graphique avec Bokeh

p = bplt.figure(title='Nikkei moyenne', x_axis_type='datetime', plot_width=640, plot_height=320)
p.segment(stocks.index, stocks.Open, stocks.index, stocks.Close, color='black')
bplt.show(p)

Utilisez * pyspark-notebook *

J'utiliserai également l'image de PySpark. Des paramètres supplémentaires sont nécessaires pour se connecter à un cluster Spark en cours d'exécution, mais une opération autonome suffira pour de simples vérifications d'opération d'API.

Téléchargez l'image * pyspark-notebook * et vérifiez la capacité.

$ docker pull jupyter/pyspark-notebook
$ docker images jupyter/pyspark-notebook
REPOSITORY                 TAG                 IMAGE ID            CREATED             SIZE
jupyter/pyspark-notebook   latest              26c919b64b68        2 days ago          4.46GB

Commencez en arrière-plan et vérifiez le jeton.

$ docker run -d --name pysparknb -p 8888:8888 jupyter/pyspark-notebook
$ docker exec pysparknb jupyter notebook list

Accédez au serveur de notebook avec un navigateur Web et créez un nouveau notebook Python 3.

Essayez de courir de haut en bas selon la documentation officielle. Comme le code source n'est pas cloné, les données sont téléchargées et utilisées individuellement.

• Spark SQL and DataFrames - Spark 2.2.0 Documentation

Créer une session Spark

from pyspark.sql import SparkSession

spark = SparkSession \
    .builder \
    .appName("Python Spark SQL basic example") \
    .config("spark.some.config.option", "some-value") \
    .getOrCreate()

Téléchargez le fichier en utilisant la commande wget.

Télécharger les données

!wget https://raw.githubusercontent.com/apache/spark/master/examples/src/main/resources/people.json

Chargez des données à l'aide de l'API DataFrame. Affichez les données et le schéma et assurez-vous également que vous pouvez sélectionner les données par spécification de colonne.

Lire les données

df = spark.read.json("people.json")
df.show()
df.printSchema()
df.select("name").show()

Assurez-vous également que vous pouvez utiliser SQL. Ce sera plus facile pour les tableaux simples.

Utilisation de SQL

df.createOrReplaceTempView("people")
sqlDF = spark.sql("SELECT * FROM people")
sqlDF.show()

Utilisez * tensorflow-notebook *

J'essaierai également d'utiliser l'image de TensorFlow. Aucun GPU ne devrait suffire pour essayer l'API TensorFlow Core.

Téléchargez l'image * tensorflow-notebook * et vérifiez la capacité.

$ docker pull jupyter/tensorflow-notebook
$ docker images jupyter/tensorflow-notebook
REPOSITORY                    TAG                 IMAGE ID            CREATED             SIZE
jupyter/tensorflow-notebook   latest              374b8bc43218        3 days ago          4.5GB

Commencez en arrière-plan et vérifiez le jeton.

$ docker run -d --name tfnb -p 8888:8888 jupyter/tensorflow-notebook
$ docker exec tfnb jupyter notebook list

Accédez au serveur de notebook avec un navigateur Web et créez un nouveau notebook Python 3.

Vérifiez le fonctionnement de l'API selon la documentation officielle.

• Getting Started With TensorFlow

Tout d'abord, importez le module et définissez le nœud constant.

import tensorflow as tf
node1 = tf.constant(3.0, dtype=tf.float32)
node2 = tf.constant(4.0)
node1, node2

Définissez une session et évaluez le nœud. Donnez aux méthodes * run () * de la session une liste de nœuds.

sess = tf.Session()
sess.run([node1, node2])

Définissez un nœud qui applique l'opération d'ajout aux deux nœuds constants et évaluez le nœud.

node3 = tf.add(node1, node2)
sess.run(node3)

Permet de donner une entrée pendant l'évaluation plutôt qu'un nœud constant. TensorFlow utilise un type de données appelé * espace réservé *. Notez que ʻa + best un raccourci pourtf.add (a, b)`.

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b

Spécifiez une valeur pour l'argument * feed_dict * lors de l'appel de la méthode * run () * de la session.

sess.run(adder_node, {a: 3, b: 4.5})

Si vous donnez un argument sous forme de liste, l'opération d'ajout est appliquée à chaque élément. N'est-il pas pratique de traiter les constantes et les vecteurs de la même manière?

sess.run(adder_node, {a: [1, 3], b: [2, 4]})

Le flux de connexion des nœuds et de leur évaluation dans une session est le même pour les autres opérations. Cependant, le traitement des fractions peut être différent de ce à quoi vous vous attendiez dans les opérations fractionnaires, soyez donc prudent lorsque vous vérifiez l'opération avec un simple calcul.

add_and_triple = adder_node * 3.
sess.run(add_and_triple, {a: [1, 2], b: [3.4, 5.6]})

Ce qui précède est résumé dans un cahier comme suit.

La documentation officielle explique à partir de là comment gérer l'apprentissage automatique. Il décrit comment définir des variables pour définir un modèle linéaire ou fournir des données d'apprentissage pour créer un modèle et évaluer les résultats de l'exécution. Vous pouvez également essayer la reconnaissance d'image MNIST avec le module * tensorflow.examples.tutorials.mnist *, c'est donc une bonne idée de lire les didacticiels dans l'ordre.

Résumé

Maintenant que l'image Jupyter Docker a été nettoyée, j'ai essayé d'utiliser * base-notebook *, * scipy-notebook *, * pyspark-notebook *, * tensorflow-notebook *.

Le nombre d'ensembles d'outils disponibles en science des données augmente et la gestion de chacun d'entre eux peut être difficile, mais l'utilisation d'une image Docker peut éliminer la complexité du déploiement initial. Le déploiement à grande échelle et le réglage des performances sont également des préoccupations, mais dans les environnements cloud tels qu'AWS et GCP, l'utilisation de conteneurs est également simplifiée, ce qui facilite la création d'un environnement de reproduction hautement portable. On peut dire qu'il est bon que la gamme de choix augmente, comme utiliser correctement les images publiques en fonction de l'objectif ou se développer par vous-même.