forked from CDS/infrastruktur-dok
218 lines
10 KiB
Markdown
218 lines
10 KiB
Markdown
# Softwareinstalltionen auf den Workstations
|
|
|
|
Da es sich bei allen Rechnern um **Mehrbenutzersysteme** handelt, ist der Zugriff mit **su oder sudo auf den Workstations abgeschaltet**. Um zusätzliche Software für Berechnungen wie Tensorflow zu installieren, gibt es folgende zwei Möglichkeiten:
|
|
|
|
- Apptainer
|
|
- Miniconda
|
|
|
|
|
|
*Hinweis: Docker ist auf den HPC Workstations nicht verfügbar. Docker-Container können jedoch mit der Software 'Apptainer' ausgeführt werden*
|
|
|
|
## Apptainer
|
|
|
|
Apptainer (ehemals Singularity) ist ein *Containersystem* das für den Einsatz auf HPC Systemen optimiert ist. Apptainer unterstützt verschiedene Clustertechnologien wie Infiniband, SLURM oder MPI. Da Apptainer den OCI Standard unterstützt, können neben Apptainerimages auch Images von Dockerhub oder Nvidia (https://catalog.ngc.nvidia.com/containers) unter Apptainer ausgeführt werden.
|
|
|
|
Auf unseren Workstations kann damit in einem Container eine Runtime für GPU und CPU Berechnungen mit Tensorflow, Pytorch, etc. ausgeführt werden.
|
|
|
|
Neben diesen vorbereiteten Images ist es auch möglich, einen Container von Grund auf neu zu bauen, falls es kein entsprechendes Image mit der benötigten Software gibt. Da dies jedoch ein aufwendigeres Unterfangen ist, wird an dieser Stelle nur auf die Dokumentation verwiesen. Diese ist unter https://apptainer.org/docs/user/main/quick_start.html#building-images-from-scratch zu finden.
|
|
|
|
## Miniconda
|
|
|
|
Miniconda ist eine virtuelle Environment (offiziell eine Distribution) über die im Homeverzeichnis mit dem Paketmanager `conda` Software für die Programmierung im Data Science Bereich installiert werden kann. Wie Miniconda und Pakete für Tensorflow installiert werden können, ist im Abschnitt *Installation von Software mit Miniconda* und *Installieren von Tensorflow mit Conda* beschrieben
|
|
|
|
### Installieren von Tensorflow mit Apptainer
|
|
|
|
Damit Tensorflow die GPUs auf den Workstations zur Berechnung nutzt, **müssen verschiedene Komponenten** im Container und auf der Workstation vorhanden sein. Grundsätzlich sind dies:
|
|
|
|
| 
|
|
|:--:
|
|
| Software Stack für Docker/Apptainer GPU Berechnungen
|
|
|
|
Auf den Workstations bereits installiert sind:
|
|
|
|
* GPU Treiber (Nvidia Treiber)
|
|
* CUDA
|
|
|
|
Wie aus der Grafik ersichtlich ist, brauchen wir im Container Tensorflow. Dieses könnten wir von Hand in den Container installieren, z.B. in dem Fall, wenn eine spezifizierte Version benötigt wird. Es gibt jedoch eine grosse Pallette an vorgefertigten Images von Dockerhub oder Nvidia. Um uns das Ingeunieursleben etwas zu erleichtern, verwenden wir folgend einen vorgefertigten Container.
|
|
|
|
Falls uns jedoch im Container noch ein bestimmtes Softwarepaket fehlt, ist es möglich, mit Hilfe einer Container-Sandbox dieses zu installieren und danach ein modifiziertes und auf unsere Bedürfnisse angepasstes Containerimage zu generieren.
|
|
|
|
Auf einer der verfügbaren Workstations mit SSH einloggen und dann mit Slurm eine interaktive Session unter Verwendung einer GPU starten:
|
|
|
|
```
|
|
salloc -p students -G a100:1 --cpus-per-task=16 --mem=7G
|
|
```
|
|
|
|
Danach können wir mit dem folgenden Befehl eine Verzeichnishierarchie für den Buildvorgang erstellen:
|
|
|
|
```
|
|
mkdir -p ~/build-apptainer/sandboxes/ && cd ~/build-apptainer
|
|
```
|
|
Container mit bereits installierter Tensorflowsoftware können von Dockerhub oder von der Nvidia-Registry bezogen werden. Dabei wird das Docker Imageformat automatisch ins Apptainerformat (.sif) umgewandelt. Hier könnten wir auch eine neuere Version des Tensorflowimages angeben. Im nachfolgenden Beispiel benutzen wir die Docker-Registry um Tensorflow 2.16.1 zu beziehen:
|
|
|
|
```
|
|
apptainer pull tensorflow-2.16.1-gpu.sif docker://tensorflow/tensorflow:2.16.1-gpu
|
|
```
|
|
|
|
Der vorherige Befehl speichert das Tensorflowimage im Homeverzeichnis unter build-apptainer ab. Falls Apptainer sich beim Download des Images über mangelnden Speicherplatz beklagt, gibt es unter dem Abschnitt "Troubleshooting" Tipps, wie in einem solchen Fall vorgegangen werden kann.
|
|
|
|
Als nächstes bauen wir ein neues Tensorflowimage und installieren als Beispiel das Paket nvidia-profiler in das Image nach. Dazu benutzen wir als Basis das bereits heruntergeladene Tensorflowimage (tensorflow-dockerhub.sif) das wir bereits mit `aptainer pull` in unser Homeverzeichnis gespeichert haben:
|
|
|
|
```
|
|
apptainer build --sandbox sandboxes/tensorflow ./tensorflow-2.16.1-gpu.sif
|
|
apptainer exec --fakeroot --writable sandboxes/tensorflow/ apt-get update
|
|
apptainer exec --writable --fakeroot sandboxes/tensorflow/ apt install -y nvidia-profiler
|
|
```
|
|
Da auf den Homedirectories eine Diskquota von 80GB aktiviert ist, kann es sein, dass wir dadurch zu wenig Speicherplatz haben um das Image zu bauen. Daher bauen wir ein neues Tensorflowimage auf dem scratch:
|
|
|
|
```
|
|
mkdir -p "/scratch/${USER}/"
|
|
apptainer build "/scratch/${USER}/tensorflow-2.16.1-gpu-modified.sif" sandboxes/tensorflow/
|
|
```
|
|
Danach können wir interaktiv im Container arbeiten. Apptainer mountet das Homeverzeichnis automatisch in den Container, daher stehen unsere Skripts die wir für eine Berechnung brauchen automatisch zur Verfügung.
|
|
|
|
Mit dem Befehl ```apptainer shell``` können wir ein Apptainerimage öffnen und darin arbeiten.
|
|
|
|
```
|
|
apptainer shell --nv "/scratch/${USER}/tensorflow-2.16.1-gpu-modified.sif"
|
|
```
|
|
Jetzt könne wir überprüfen ob die GPUs im Container korrekt erkannt werden:
|
|
|
|
```
|
|
python3 <<- EOF
|
|
import tensorflow as tf
|
|
print(tf.config.list_physical_devices('GPU')[0])
|
|
EOF
|
|
```
|
|
Der Output sollte dann, je nach Anzahl GPUs, wie folgt aussehen:
|
|
|
|
> PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')
|
|
|
|
|
|
|
|
## Installation von Software mit Miniconda
|
|
|
|
```
|
|
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
|
|
bash Miniconda3-latest-Linux-x86_64.sh
|
|
rm Miniconda3-latest-Linux-x86_64.sh
|
|
```
|
|
Danach die .bashrc nochmals neu laden (dies ist nur einmalig nötig)
|
|
```
|
|
. ~/.bashrc
|
|
```
|
|
|
|
Neue virtuelle Umgebung erstellen und aktivieren
|
|
```
|
|
conda create --name <ENVNAME>
|
|
conda activate <ENVNAME>
|
|
```
|
|
Die verfügbaren virtuellen Umgebungen können mit `conda env list` angezeigt werden.
|
|
|
|
Jetzt kann Software, zum Beispiel Pandas oder Tensorflow, wie folgt installiert werden:
|
|
|
|
```
|
|
conda search <PKGNAME>
|
|
conda install <PKGNAME>
|
|
```
|
|
|
|
Mit conda installierte Pakete können bei Bedarf mit dem 'update' Befehl aktualisiert werden. Für Python 3 wäre das:
|
|
|
|
```conda update python3```
|
|
|
|
Update aller Pakete in der momentan aktivierten Conda Environment:
|
|
|
|
```conda update --all```
|
|
|
|
Update von Conda selbst:
|
|
|
|
```conda update -n base -c defaults conda```
|
|
|
|
## Installieren von Tensorflow mit Conda
|
|
|
|
Damit wir für die Installation von Tensorflow einen erkennbaren GPU zur Verfügung haben, müssen wir eine interaktive Slurm-Session starten:
|
|
|
|
```
|
|
salloc -p students -G a100:1 --cpus-per-task=16 --mem=7G
|
|
```
|
|
|
|
Dann erstellen wir eine neue Conda Environment die Python 3.12 enthält:
|
|
|
|
```
|
|
conda create --name tf -y python=3.12
|
|
conda activate tf
|
|
conda install pip
|
|
pip install --upgrade pip
|
|
```
|
|
|
|
Damit Tensorflow die GPUs nutzen kann, müssen die Treiber korrekt installiert sein. Dies können wir mit dem Befehl `nvidia-smi` überprüfen:
|
|
|
|
| 
|
|
|:--:
|
|
| Output im Falle von korrekt erkannter GPU
|
|
|
|
Danach installieren wir das Cuda Toolkit, CuDNN und Tensorflow:
|
|
|
|
```
|
|
conda install -c conda-forge -y cudatoolkit=11.8.0
|
|
pip install tensorflow[and-cuda]
|
|
|
|
CUDNN_PATH=$(dirname $(python -c "import nvidia.cudnn;print(nvidia.cudnn.__file__)"))
|
|
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CONDA_PREFIX/lib/:$CUDNN_PATH/lib
|
|
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH#:}
|
|
```
|
|
|
|
Mit den letzten drei Befehlen werden die Variabeln **LD_LIBRARY_PATH** und **CUDNN_PATH** gesetzt. Tensorflow funktioniert nur richtig, wenn diese Variabeln korrekte Pfade enthalen. Deren Output sieht in etwa so aus (kann je nach OS, eingeloggtem Benutzer und Version etwas abweichen):
|
|
|
|
`echo $LD_LIBRARY_PATH`
|
|
|
|
> /home/$USER@edu.local/miniconda3/envs/tf/lib/:/home/$USER@edu.local/miniconda3/envs/tf/lib/python3.9/site-packages/nvidia/cudnn/lib:/home/$USER@edu.local/miniconda3/envs/tf/lib/:/home/$USER@edu.local/miniconda3/envs/tf/lib/python3.9/site-packages/nvidia/cudnn/lib
|
|
|
|
`echo $CUDNN_PATH`
|
|
|
|
> /home/$USER@edu.local/miniconda3/envs/tf/lib/python3.9/site-packages/nvidia/cudnn
|
|
|
|
Damit wir diese Variabeln nicht in jeder Terminalsession erneut setzen müssen, können diese mit den Befehlen
|
|
```
|
|
mkdir -p $CONDA_PREFIX/etc/conda/activate.d
|
|
echo 'CUDNN_PATH=$(dirname $(python -c "import nvidia.cudnn;print(nvidia.cudnn.__file__)"))' >> $CONDA_PREFIX/etc/conda/activate.d/env_vars.sh
|
|
echo 'LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CONDA_PREFIX/lib/:$CUDNN_PATH/lib' >> $CONDA_PREFIX/etc/conda/activate.d/env_vars.sh
|
|
echo 'export LD_LIBRARY_PATH=${LD_LIBRARY_PATH#:}' >> $CONDA_PREFIX/etc/conda/activate.d/env_vars.sh
|
|
```
|
|
permanent in der Conda Environment gespeichert werden.
|
|
|
|
Nun können wir überprüfen ob Tensorflow die GPUs erkennt:
|
|
```
|
|
python3 -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"
|
|
```
|
|
Wenn alles richtig funktioniert, gibt der letzte Befehl Informationen zu den GPUs aus. Dies sieht, abhängig von der verbauten Hardware, etwa so aus:
|
|
|
|
| 
|
|
|:--:
|
|
| Korrekt erkannte GPUs in Python
|
|
|
|
|
|
## Troubleshooting
|
|
|
|
Auf den Workstations ist eine Quota von 80GB pro Person und Homeverzeichnis gesetzt. Beim erstellen von Apptainerimages, ist es möglich, dass diese Quota überschritten wird und es folglich zu Abbrüchen und Fehlermeldungen kommt.
|
|
|
|
Mit dem Befehl `quota -s` kann angezeigt werden, wieviel Speicherplatz auf dem Homeverzeichnis übrig ist. Falls die Quota aufgebraucht ist, kann mit dem Befehl
|
|
|
|
```
|
|
apptainer cache clean -D 30
|
|
```
|
|
Apptainerimages die älter als 30 Tage sind gelöscht werden.
|
|
|
|
Falls immer noch zuwenig Speicherplatz im Homeverzeichnis vorhanden ist, kann mit dem Befehl
|
|
```
|
|
du -sh .[^..]* * | sort -h
|
|
```
|
|
herausgefunden werden in welchem Unterzeichnis die meisten Daten belegt werden.
|
|
|
|
Daten die im Verzeichnis **/scratch** abgelegt werden, unterliegen übrigens keiner Quota.
|
|
|
|
|
|
### Tensorflow Performance analysieren
|
|
|
|
https://www.tensorflow.org/guide/gpu_performance_analysis
|