Jouez avec un carnet d'images personnalisé avec Kubeflow v0.71

Une sorte de bon timing

――Kubeflow v1.0 RC a été publié au moment de la rédaction de cet article. ――Dans mon environnement v0.71, certaines fonctions telles que Pipeline et Kalib ne fonctionnent pas, j'aimerais donc essayer la v1.0RC dès que possible ... ――Mais j'ai écrit un article sur la v0.71, donc il sert également de service commémoratif (la plupart des étapes peuvent être converties en v1.0).

Quel est cet article?

C'est un double stand. Les pipelines et Kalib auxquels je m'attendais au début n'ont pas bien fonctionné, alors utilisons la v1.0RC la prochaine fois, elle se termine par (Je voulais faire du pré-traitement de la création de pipeline et du réglage des paramètres avec les données Titanic de Kaggle)

Contexte de la tentative d'utilisation de Kubeflow

Je travaille parfois sur un projet d'apprentissage automatique,

J'ai ressenti un problème avec de telles choses. Au début, je devais préparer moi-même les outils et les gérer, mais maintenant je dois passer plus de temps sur le travail d'analyse de données (activité principale), et finalement je laisse les outils seuls. Personne ne pouvait utiliser les outils obsolètes, et personne d'autre ne pouvait faire la vérification de l'exactitude ou le prétraitement des données pour l'apprentissage.

J'ai décidé d'essayer Kubeflow, en demandant si "Kubeflow", que j'entends souvent dans le contexte de MLOps, pouvait améliorer la situation ci-dessus.

procédure

Dans cet article, nous préparerons l'environnement kubernetes et Kubeflow dans l'environnement Ubuntu 18.04. De plus, on suppose que Docker a été configuré séparément.

Installez k8s avec microk8s

Avant Kubeflow, préparez l'environnement kubernetes (k8s). Il y a plusieurs façons de le construire, mais cette fois je l'ai construit en utilisant les microk8s les plus simples.

(En passant, à partir de Kubeflow v1.0 RC, kubeflow est fourni en tant que complément à microk8s. C'était bien de choisir microk8s.)

Veuillez vous référer au site suivant pour l'installation. https://v0-7.kubeflow.org/docs/other-guides/virtual-dev/getting-started-multipass/

Il est scripté et se termine en seulement 6 lignes.

git clone https://github.com/canonical-labs/kubernetes-tools
cd kubernetes-tools
git checkout eb91df0 # v1.Paiement car il peut être mis à jour pour 0
sudo ./setup-microk8s.sh
microk8s.enable registry #Nécessaire pour utiliser votre propre image Notebook
microk8s.enable gpu #Si vous avez un GPU

Ce script installe les microk8s v1.15 Veuillez noter que la dernière version de microk8s entrée par snap install est v.1.17 et Kubeflow v0.7 n'est pas prise en charge.

Après l'installation,

kubectl get pod --all-namespaces

Assurez-vous que tous les pods sont en cours d'exécution.

(Facultatif) Accès à Kubernetes Dashborad

Accédez au tableau de bord k8s pour vous aider lors du débogage:

Tapez la commande suivante et enregistrez le TOKEN de sortie

token=$(microk8s.kubectl -n kube-system get secret | grep default-token | cut -d " " -f1)
microk8s.kubectl -n kube-system describe secret $token

Redirection de port

microk8s.kubectl port-forward -n kube-system service/kubernetes-dashboard 10443:443 --address=0.0.0.0

Accédez à https: // <nom d'hôte>: 10443 et connectez-vous avec le TOKEN précédent.

サインイン_-_Kubernetes_Dashboard.png

Lorsque le tableau de bord est affiché, c'est OK.

installation de kubeflow

https://v0-7.kubeflow.org/docs/started/k8s/kfctl-k8s-istio/ Suivez les étapes de.

(Il existe également un script appelé kubeflow-tools comme les kubernetes-tools utilisé précédemment, mais je ne l'ai pas utilisé car la version installée de kubeflow est ancienne.)

téléchargement binaire kfctl

wget https://github.com/kubeflow/kubeflow/releases/download/v0.7.1/kfctl_v0.7.1-2-g55f9b2a_linux.tar.gz
tar -xvf kfctl_v0.7.1-2-g55f9b2a_linux.tar.gz

Définir les variables d'environnement


#Placez le fichier exécutable kfctl dans le PATH
export PATH=$PATH:"<path-to-kfctl>"

#Nommez le déploiement de manière appropriée(L’écrivain est «kf-yums')
export KF_NAME=<your choice of name for the Kubeflow deployment>

#Répertoire pour placer les fichiers yaml, etc.(L'écrivain est`~/.local/`)
export BASE_DIR=<path to a base directory>

export KF_DIR=${BASE_DIR}/${KF_NAME}
export CONFIG_URI="https://raw.githubusercontent.com/kubeflow/manifests/v0.7-branch/kfdef/kfctl_k8s_istio.0.7.1.yaml"

Installation

mkdir -p ${KF_DIR}
cd ${KF_DIR}
#Cela peut ne pas réussir à un moment donné. Réessayez plusieurs fois.
kfctl apply -V -f ${CONFIG_URI}

Si vous exécutez kubectl get pod --all-namespaces, vous verrez que de nombreux conteneurs ont été créés. Attendez un moment jusqu'à ce que tout soit en cours d'exécution.

Accéder au tableau de bord kubeflow

Redirection de port

#Tout le monde peut y accéder, il est donc préférable de restreindre l'accès le cas échéant.
kubectl port-forward -n istio-system svc/istio-ingressgateway 10080:80 --address 0.0.0.0

Si vous accédez au port 10080 avec http, le tableau de bord (écran de bienvenue) apparaît.

Notez que cette configuration pose un problème de sécurité car toute personne connaissant l'URL peut y accéder. Lorsque vous l'utilisez en interne, il peut être préférable d'utiliser Dex etc. pour protéger le mot de passe ou envisager des restrictions d'accès par redirection de port.

Kubeflow_Central_Dashboard.png

Au fur et à mesure que vous avancez, vous serez redirigé vers l'écran de création de Namespace, alors réglez-le correctement (j'ai choisi kf-yums).

Kubeflow_Central_Dashboard.png

Vous pouvez accéder au tableau de bord Kubeflow avec Terminer.

Kubeflow_Central_Dashboard.png

Configurer Notebook Server avec votre propre image

L'une des fonctionnalités de Kubeflow est la fonction d'hébergement de Jupyter Notebook. Tout le monde peut facilement créer un environnement Oreore Notebook simplement en spécifiant les ressources nécessaires telles que la mémoire, le processeur, (GPU) et l'environnement (image Docker). Vous pouvez réduire le temps nécessaire pour créer une infrastructure d'analyse.

Utilisez cette fonction pour héberger votre propre image Docker avec Jupyter Notebook. Il permet également de se référer aux données sur le terminal exécutant k8s depuis Notebook.

Construisez votre propre image et Push

https://www.kubeflow.org/docs/notebooks/custom-notebook/ Je recommande de faire référence à.

Pour le moment, j'ai créé un Dockerfile comme celui ci-dessous, me demandant si je devais utiliser RandomForest ou quelque chose.

FROM python:3.8-buster
RUN pip --no-cache-dir install pandas numpy scikit-learn jupyter

ENV NB_PREFIX /
EXPOSE 8888
CMD ["sh","-c", "jupyter notebook --notebook-dir=/home/jovyan --ip=0.0.0.0 --no-browser --allow-root --port=8888 --NotebookApp.token='' --NotebookApp.password='' --NotebookApp.allow_origin='*' --NotebookApp.base_url=${NB_PREFIX}"]

Construire.

docker build -t myimage .

Pour pousser cette image vers le registre de conteneurs microk8s (localhost: 32000), modifiez daemon.json comme suit.

> sudo vim /etc/docker/daemon.json

Ajoutez ce qui suit

{
    "insecure-registries" : ["localhost:32000"]
}

Après l'ajout, redémarrez Docker et poussez vers le registre microk8s.

sudo systemctl restart docker
docker tag myimage:latest localhost:32000/myimage:latest
docker push localhost:32000/myimage:latest

Vous pouvez voir l'image poussée dans le registre comme suit:

microk8s.ctr -n k8s.io images ls | grep myimage

Rendre possible la référence aux données du terminal depuis Notebook

L'image Notebook créée ci-dessus n'inclut pas les données d'entrée (ce n'est généralement pas le cas) Créez à l'avance «PV» et «PVC» afin de pouvoir vous référer aux données d'entrée sur le nœud depuis Notebook.

Ici, rendons l'ensemble de données Titanic de Kaggle situé dans / data / titanic / visible depuis Notebook.

#On suppose que les données téléchargées à l'avance à partir de kaggle sont placées.
> find /data/titanic

titanic/gender_submission.csv
titanic/train.csv
titanic/test.csv

Définissez «PersistentVolume (PV)» et «PersistentVolumeClaim (PVC)» comme suit.


kind: PersistentVolume
apiVersion: v1
metadata:
  name: titanic-pv
  namespace: <espace de noms créé par kubeflow>
spec:
  storageClassName: standard
  capacity:
    storage: 1Gi
  claimRef:
    namespace: <espace de noms créé par kubeflow>
    name: titanic-pvc
  accessModes:
  - ReadWriteOnce
  hostPath:
    path: /data/titanic/
---
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: titanic-pvc
  namespace: <espace de noms créé par kubeflow>
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

Enregistrez-le sous titanic_data.yaml et

kubectl apply -f titanic_data.yaml

Le volume est maintenant créé. En spécifiant ce volume lors de la création de Notebook Server, vous pouvez vous référer aux données qu'il contient à partir de Notebook.

Créer un serveur Notebook

Depuis le tableau de bord Kubeflow, allez dans Serveurs Notebook-> NOUVEAU SERVEUR. Kubeflow_Central_Dashboard.png

Lorsque vous passez à l'écran de création de notebook, Cochez l'option Image personnalisée dans l'élément ʻImage` et poussez d'abord l'image.

localhost:32000/myimage:latest

Est spécifié.

Kubeflow_Central_Dashboard.png

--Nom du serveur de notes

Est défini de manière appropriée.

Kubeflow_Central_Dashboard.png

Dans l'élément DataVolumes, spécifiez le PVC créé précédemment.

Kubeflow_Central_Dashboard.png

Après avoir réglé ce qui précède, appuyez sur CRÉER en bas

Kubeflow_Central_Dashboard.png

Notebook Server démarrera dans quelques secondes. (S'il ne démarre pas, quelque chose ne va pas dans les coulisses. Vous pouvez le voir sur le tableau de bord du k8.)

Appuyez sur CONNECT et l'écran habituel de Jupyter Notebook apparaîtra. Bien sûr, les données Titanic sont également montées.

data-vol-1_.png

Après cela, créez un notebook comme d'habitude et analysez diverses données.

Untitled_-_Jupyter_Notebook.png

Fonctions qui ne peuvent pas être utilisées en dehors du Notebook Server

Maintenant que vous avez hébergé votre Notebook Server, Kubeflow propose de nombreuses autres fonctionnalités.

D'un intérêt particulier

--Pipeline qui peut effectuer le traitement des données, l'apprentissage, l'exécution du traitement des inférences et le suivi de divers KPI

2 fonctions. Mais ces deux ... ne fonctionnaient pas dans mon environnement.

Pipeline se plaint qu'il n'y a pas de Docker lors de l'exécution de Job. La cause principale était que microk8s utilisait «containerd» au lieu de «Docker» pour exécuter le conteneur. La question a également été soulevée.

Lorsque Kalib exécute également Job,

INFO:hyperopt.utils:Failed to load dill, try installing dill via "pip install dill" for enhanced pickling support.
INFO:hyperopt.fmin:Failed to load dill, try installing dill via "pip install dill" for enhanced pickling support.

Le message est émis et le processus ne se poursuit pas. Bien qu'il soit fermé, issue est

Les deux ont une odeur qui semble être résolue par Update, donc je vais essayer Kubeflow v1.0 RC immédiatement.

Recommended Posts

Jouez avec un carnet d'images personnalisé avec Kubeflow v0.71
Jouer avec Jupyter Notebook (IPython Notebook)
Formatage avec autopep8 sur le notebook Jupyter
Jouez avec Turtle sur Google Colab
Remarques sur l'exécution de M5Stick V avec uPyLoader
Essayez SVM avec scikit-learn sur Jupyter Notebook
[Explication avec image] Utilisez pickle avec le carnet de notes de Kaggle
Construire des stratégies de trading sur SmartTrade avec des fonctions personnalisées
Utilisation de MLflow avec Databricks ① - Suivi expérimental sur notebook -
Activer Jupyter Notebook avec conda sur un serveur distant
Jouez avec Prophet
Jouez avec PyTorch
Jouez avec 2016-Python
Jouez avec CentOS 8
Jouez avec Pyramid
Jouez avec Fathom
Remarques sur le traitement d'images HDR et RAW avec Python
Surveiller le modèle d'entraînement avec TensorBord sur Jupyter Notebook
Approvisionnement EC2 avec Vagrant + Jupyter (IPython Notebook) sur Docker