diff --git a/Python/QA-007-Restore-Conda-Environments.ipynb b/Python/QA-007-Restore-Conda-Environments.ipynb index 1368f4ece36f35032fc776fcccebd4f1c29d2120..a84c7eb699a1a4148f7e24b3f150e3f91d5ded31 100644 --- a/Python/QA-007-Restore-Conda-Environments.ipynb +++ b/Python/QA-007-Restore-Conda-Environments.ipynb @@ -203,7 +203,7 @@ "./envs/test/bin/pip list format=freeze > requirements.txt\n", "```\n", "\n", - "However, this is quite different from conda. You need to have the correct version of python available otherwise you can not restore the environment." + "However, this is quite different from conda. You need to have the **correct version of python** available otherwise you can not restore the environment." ] }, { @@ -612,7 +612,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Anaconda3 (2020.07)", + "display_name": "Miniconda3 (4.10.3) - 3.9.5", "language": "python", "name": "python3" }, @@ -626,7 +626,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.9.5" } }, "nbformat": 4, diff --git a/Python/QA-008-Dask-Dashboard.ipynb b/Python/QA-008-Dask-Dashboard.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..ceeec255d29de0bae07a73e837ab17e316b5fcc2 --- /dev/null +++ b/Python/QA-008-Dask-Dashboard.ipynb @@ -0,0 +1,511 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "75991dfb-8d44-4b9f-8b41-d4f8ff3b078a", + "metadata": {}, + "source": [ + "# Dask Dashboard\n", + "\n", + "It is a really nice feature from dask distributed to have a dashboard of currently running processes.\n", + "\n", + "However, the default configuration sets the link wrong." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "72125cc8-62c2-4332-9388-5e9806fb44c6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/swd/spack/opt/spack/linux-rhel8-skylake_avx512/gcc-8.4.1/anaconda3-2020.11-v46okvjlotnor7yrmpqnbn63xt3a2qyq/lib/python3.8/site-packages/distributed/node.py:151: UserWarning: Port 8787 is already in use.\n", + "Perhaps you already have a cluster running?\n", + "Hosting the HTTP server on port 33323 instead\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "<table style=\"border: 2px solid white;\">\n", + "<tr>\n", + "<td style=\"vertical-align: top; border: 0px solid white\">\n", + "<h3 style=\"text-align: left;\">Client</h3>\n", + "<ul style=\"text-align: left; list-style: none; margin: 0; padding: 0;\">\n", + " <li><b>Scheduler: </b>tcp://127.0.0.1:37781</li>\n", + " <li><b>Dashboard: </b><a href='http://127.0.0.1:33323/status' target='_blank'>http://127.0.0.1:33323/status</a></li>\n", + "</ul>\n", + "</td>\n", + "<td style=\"vertical-align: top; border: 0px solid white\">\n", + "<h3 style=\"text-align: left;\">Cluster</h3>\n", + "<ul style=\"text-align: left; list-style:none; margin: 0; padding: 0;\">\n", + " <li><b>Workers: </b>1</li>\n", + " <li><b>Cores: </b>4</li>\n", + " <li><b>Memory: </b>809.71 GB</li>\n", + "</ul>\n", + "</td>\n", + "</tr>\n", + "</table>" + ], + "text/plain": [ + "<Client: 'tcp://127.0.0.1:37781' processes=1 threads=4, memory=809.71 GB>" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from dask.distributed import Client, progress\n", + "client = Client(threads_per_worker=4, n_workers=1)\n", + "client" + ] + }, + { + "cell_type": "markdown", + "id": "c821adfe-bee1-484d-b4e6-92fb0520d65c", + "metadata": {}, + "source": [ + "this local Link: `Dashboard: http://127.0.0.1:33323/status` can not be reached from the TeachingHub." + ] + }, + { + "cell_type": "markdown", + "id": "1e7e0c38-b34f-4b89-94eb-3115009bfb94", + "metadata": {}, + "source": [ + "## Fix the configuration\n", + "This will add the required configuration options.\n", + "\n", + "*Note: Check by hand, if you have more options enabled*" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "33c446da-8569-49ee-961a-1696d457d499", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Appending to /home/spack/.config/dask/distributed.yaml\n" + ] + } + ], + "source": [ + "%%writefile -a ~/.config/dask/distributed.yaml\n", + "distributed:\n", + " dashboard:\n", + " link: \"/hub/user/{JUPYTERHUB_USER}/proxy/{port}/status\"" + ] + }, + { + "cell_type": "markdown", + "id": "68eacd94-042d-4d76-81b5-fb8f6bdce990", + "metadata": {}, + "source": [ + "## Distributed configuration file" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "51821038-f1c9-4e58-9f15-85d3f567e6a3", + "metadata": {}, + "outputs": [], + "source": [ + "# %load ~/.config/dask/distributed.yaml\n", + "# distributed:\n", + "# version: 2\n", + "# # logging:\n", + "# # distributed: info\n", + "# # distributed.client: warning\n", + "# # bokeh: critical\n", + "# # # http://stackoverflow.com/questions/21234772/python-tornado-disable-logging-to-stderr\n", + "# # tornado: critical\n", + "# # tornado.application: error\n", + "\n", + "# scheduler:\n", + "# allowed-failures: 3 # number of retries before a task is considered bad\n", + "# bandwidth: 100000000 # 100 MB/s estimated worker-worker bandwidth\n", + "# blocked-handlers: []\n", + "# default-data-size: 1kiB\n", + "# # Number of seconds to wait until workers or clients are removed from the events log\n", + "# # after they have been removed from the scheduler\n", + "# events-cleanup-delay: 1h\n", + "# idle-timeout: null # Shut down after this duration, like \"1h\" or \"30 minutes\"\n", + "# transition-log-length: 100000\n", + "# work-stealing: True # workers should steal tasks from each other\n", + "# work-stealing-interval: 100ms # Callback time for work stealing\n", + "# worker-ttl: null # like '60s'. Time to live for workers. They must heartbeat faster than this\n", + "# pickle: True # Is the scheduler allowed to deserialize arbitrary bytestrings\n", + "# preload: [] # Run custom modules with Scheduler\n", + "# preload-argv: [] # See https://docs.dask.org/en/latest/setup/custom-startup.html\n", + "# unknown-task-duration: 500ms # Default duration for all tasks with unknown durations (\"15m\", \"2h\")\n", + "# default-task-durations: # How long we expect function names to run (\"1h\", \"1s\") (helps for long tasks)\n", + "# rechunk-split: 1us\n", + "# shuffle-split: 1us\n", + "# validate: False # Check scheduler state at every step for debugging\n", + "# dashboard:\n", + "# status:\n", + "# task-stream-length: 1000\n", + "# tasks:\n", + "# task-stream-length: 100000\n", + "# tls:\n", + "# ca-file: null\n", + "# key: null\n", + "# cert: null\n", + "# bokeh-application: # keywords to pass to BokehTornado application\n", + "# allow_websocket_origin: [\"*\"]\n", + "# keep_alive_milliseconds: 500\n", + "# check_unused_sessions_milliseconds: 500\n", + "# locks:\n", + "# lease-validation-interval: 10s # The time to wait until an acquired semaphore is released if the Client goes out of scope\n", + "# lease-timeout: 30s # The timeout after which a lease will be released if not refreshed\n", + "\n", + "# http:\n", + "# routes:\n", + "# - distributed.http.scheduler.prometheus\n", + "# - distributed.http.scheduler.info\n", + "# - distributed.http.scheduler.json\n", + "# - distributed.http.health\n", + "# - distributed.http.proxy\n", + "# - distributed.http.statics\n", + "\n", + "# worker:\n", + "# blocked-handlers: []\n", + "# multiprocessing-method: spawn\n", + "# use-file-locking: True\n", + "# connections: # Maximum concurrent connections for data\n", + "# outgoing: 50 # This helps to control network saturation\n", + "# incoming: 10\n", + "# preload: [] # Run custom modules with Worker\n", + "# preload-argv: [] # See https://docs.dask.org/en/latest/setup/custom-startup.html\n", + "# daemon: True\n", + "# validate: False # Check worker state at every step for debugging\n", + "# lifetime:\n", + "# duration: null # Time after which to gracefully shutdown the worker\n", + "# stagger: 0 seconds # Random amount by which to stagger lifetimes\n", + "# restart: False # Do we ressurrect the worker after the lifetime deadline?\n", + "\n", + "# profile:\n", + "# interval: 10ms # Time between statistical profiling queries\n", + "# cycle: 1000ms # Time between starting new profile\n", + "# low-level: False # Whether or not to include low-level functions\n", + "# # Requires https://github.com/numba/stacktrace\n", + "\n", + "# # Fractions of worker memory at which we take action to avoid memory blowup\n", + "# # Set any of the lower three values to False to turn off the behavior entirely\n", + "# memory:\n", + "# target: 0.60 # target fraction to stay below\n", + "# spill: 0.70 # fraction at which we spill to disk\n", + "# pause: 0.80 # fraction at which we pause worker threads\n", + "# terminate: 0.95 # fraction at which we terminate the worker\n", + "\n", + "# http:\n", + "# routes:\n", + "# - distributed.http.worker.prometheus\n", + "# - distributed.http.health\n", + "# - distributed.http.statics\n", + "\n", + "# nanny:\n", + "# preload: [] # Run custom modules with Nanny\n", + "# preload-argv: [] # See https://docs.dask.org/en/latest/setup/custom-startup.html\n", + "\n", + "# client:\n", + "# heartbeat: 5s # Interval between client heartbeats\n", + "# scheduler-info-interval: 2s # Interval between scheduler-info updates\n", + "\n", + "# deploy:\n", + "# lost-worker-timeout: 15s # Interval after which to hard-close a lost worker job\n", + "# cluster-repr-interval: 500ms # Interval between calls to update cluster-repr for the widget\n", + "\n", + "# adaptive:\n", + "# interval: 1s # Interval between scaling evaluations\n", + "# target-duration: 5s # Time an entire graph calculation is desired to take (\"1m\", \"30m\")\n", + "# minimum: 0 # Minimum number of workers\n", + "# maximum: .inf # Maximum number of workers\n", + "# wait-count: 3 # Number of times a worker should be suggested for removal before removing it\n", + "\n", + "# comm:\n", + "# retry: # some operations (such as gathering data) are subject to re-tries with the below parameters\n", + "# count: 0 # the maximum retry attempts. 0 disables re-trying.\n", + "# delay:\n", + "# min: 1s # the first non-zero delay between re-tries\n", + "# max: 20s # the maximum delay between re-tries\n", + "# compression: auto\n", + "# offload: 10MiB # Size after which we choose to offload serialization to another thread\n", + "# default-scheme: tcp\n", + "# socket-backlog: 2048\n", + "# recent-messages-log-length: 0 # number of messages to keep for debugging\n", + "\n", + "# zstd:\n", + "# level: 3 # Compression level, between 1 and 22.\n", + "# threads: 0 # Threads to use. 0 for single-threaded, -1 to infer from cpu count.\n", + "\n", + "# timeouts:\n", + "# connect: 10s # time before connecting fails\n", + "# tcp: 30s # time before calling an unresponsive connection dead\n", + "\n", + "# require-encryption: null # Whether to require encryption on non-local comms\n", + "\n", + "# tls:\n", + "# ciphers: null # Allowed ciphers, specified as an OpenSSL cipher string.\n", + "# ca-file: null # Path to a CA file, in pem format, optional\n", + "# scheduler:\n", + "# cert: null # Path to certificate file for scheduler.\n", + "# key: null # Path to key file for scheduler. Alternatively, the key\n", + "# # can be appended to the cert file above, and this field\n", + "# # left blank.\n", + "# worker:\n", + "# key: null\n", + "# cert: null\n", + "# client:\n", + "# key: null\n", + "# cert: null\n", + "\n", + "\n", + "# ###################\n", + "# # Bokeh dashboard #\n", + "# ###################\n", + "\n", + "# dashboard:\n", + "# link: \"{scheme}://{host}:{port}/status\"\n", + "# export-tool: False\n", + "# graph-max-items: 5000 # maximum number of tasks to try to plot in graph view\n", + "\n", + "# ##################\n", + "# # Administrative #\n", + "# ##################\n", + "\n", + "# admin:\n", + "# tick:\n", + "# interval: 20ms # time between event loop health checks\n", + "# limit: 3s # time allowed before triggering a warning\n", + "\n", + "# max-error-length: 10000 # Maximum size traceback after error to return\n", + "# log-length: 10000 # default length of logs to keep in memory\n", + "# log-format: '%(name)s - %(levelname)s - %(message)s'\n", + "# pdb-on-err: False # enter debug mode on scheduling error\n", + "# rmm:\n", + "# pool-size: null\n", + "# ucx:\n", + "# tcp: null # enable tcp\n", + "# nvlink: null # enable cuda_ipc\n", + "# infiniband: null # enable Infiniband\n", + "# rdmacm: null # enable RDMACM\n", + "# cuda_copy: null # enable cuda-copy\n", + "# net-devices: null # define which Infiniband device to use\n" + ] + }, + { + "cell_type": "markdown", + "id": "f1c2eb2e-b45e-4468-8490-d8c340454e8d", + "metadata": {}, + "source": [ + "## Check\n", + "\n", + "1. Restart the Kernel\n", + "2. Execute Code below" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2ef493d6-3120-4d39-a5f5-f659cbdf29c0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/swd/spack/opt/spack/linux-rhel8-skylake_avx512/gcc-8.4.1/anaconda3-2020.11-v46okvjlotnor7yrmpqnbn63xt3a2qyq/lib/python3.8/site-packages/distributed/node.py:151: UserWarning: Port 8787 is already in use.\n", + "Perhaps you already have a cluster running?\n", + "Hosting the HTTP server on port 38859 instead\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "<table style=\"border: 2px solid white;\">\n", + "<tr>\n", + "<td style=\"vertical-align: top; border: 0px solid white\">\n", + "<h3 style=\"text-align: left;\">Client</h3>\n", + "<ul style=\"text-align: left; list-style: none; margin: 0; padding: 0;\">\n", + " <li><b>Scheduler: </b>tcp://127.0.0.1:37157</li>\n", + " <li><b>Dashboard: </b><a href='/hub/user/spack/proxy/38859/status' target='_blank'>/hub/user/spack/proxy/38859/status</a></li>\n", + "</ul>\n", + "</td>\n", + "<td style=\"vertical-align: top; border: 0px solid white\">\n", + "<h3 style=\"text-align: left;\">Cluster</h3>\n", + "<ul style=\"text-align: left; list-style:none; margin: 0; padding: 0;\">\n", + " <li><b>Workers: </b>1</li>\n", + " <li><b>Cores: </b>4</li>\n", + " <li><b>Memory: </b>809.71 GB</li>\n", + "</ul>\n", + "</td>\n", + "</tr>\n", + "</table>" + ], + "text/plain": [ + "<Client: 'tcp://127.0.0.1:37157' processes=1 threads=4, memory=809.71 GB>" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from dask.distributed import Client, progress\n", + "client = Client(threads_per_worker=4, n_workers=1)\n", + "client" + ] + }, + { + "cell_type": "markdown", + "id": "ce9da3d3-88bf-462f-9c95-815abef1befb", + "metadata": {}, + "source": [ + "Nevermind the warnings, but the dask dashboard tries to launch always on the same port." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d0153d40-3d9c-4168-a2fa-615d3405ce65", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dask Version 2.30.0\n", + " param_a param_b param_c param_d\n", + "0 0.061172 0.040560 0.362118 0.994508\n", + "1 0.143198 0.690496 0.987174 0.640211\n", + "2 0.781419 0.487939 0.630510 0.959628\n", + "3 0.263620 0.452732 0.355212 0.626377\n", + "4 0.695966 0.983888 0.541850 0.119032\n" + ] + } + ], + "source": [ + "import time\n", + "import random\n", + "import pandas as pd\n", + "import numpy as np\n", + "import dask\n", + "\n", + "print(\"Dask Version\", dask.__version__)\n", + "\n", + "def costly_simulation(list_param):\n", + " time.sleep(random.random())\n", + " return sum(list_param)\n", + "\n", + "input_params = pd.DataFrame(np.random.random(size=(500, 4)),\n", + " columns=['param_a', 'param_b', 'param_c', 'param_d'])\n", + "print(input_params.head())\n", + "lazy_results = []\n", + "# Setup\n", + "for parameters in input_params.values[:10]:\n", + " lazy_result = dask.delayed(costly_simulation)(parameters)\n", + " lazy_results.append(lazy_result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1a814faa-927c-4f2d-b159-01bc48aa4ff1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 155 ms, sys: 12.2 ms, total: 167 ms\n", + "Wall time: 830 ms\n" + ] + }, + { + "data": { + "text/plain": [ + "(1.4583585077669654,\n", + " 2.46107941660282,\n", + " 2.8594963768382655,\n", + " 1.6979411932760518,\n", + " 2.340735532291646,\n", + " 2.4403596176237907,\n", + " 1.9791303749343807,\n", + " 2.5719688302776786,\n", + " 2.842447070669441,\n", + " 3.013128679508103)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Execute\n", + "%time dask.compute(*lazy_results)" + ] + }, + { + "attachments": { + "f8c32ab7-040d-4064-8903-39f6f61e49dd.gif": { + "image/gif": "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" + } + }, + "cell_type": "markdown", + "id": "f2815682-4633-488f-b7a9-cf41cfbfb5ec", + "metadata": {}, + "source": [ + "\n", + "This is what should happen in the browser window when you run the compute code. Click on the Link of your Dashboard;\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70670f2c-bf43-4d0a-ba5a-efb33f17525e", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Anaconda3 (2020.11) - 3.8.5", + "language": "python", + "name": "anaconda32020.11-gcc-8.4.1" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Python/README.md b/Python/README.md index 81f55b013b911cd8e4153aacc6ceb826d755b487..b71225cbfd091d7b9ec4ec3aae04cda7bbc10275 100644 --- a/Python/README.md +++ b/Python/README.md @@ -49,3 +49,14 @@ Some are: [Add Package](QA-006-Add-Packages-to-Anaconda-Modules.ipynb) It is relativly easy to install additional packages to a anaconda module distribution with `pip install --user`. + +## Q: How to restore a conda environment? +[Save/Restore conda environment](QA-007-Restore-Conda-Environments.ipynb) + +Ever needed to backup a conda environment or copy from a colleague or designing one by hand to give to others? + +## Q: How to get the dask dashboard working on Jupyterhub? +[Fix Dask Dashboard](QA-008-Dask-Dashboard.ipynb) + +You just need to add a configuration option and then you can open the Dashboard in any Jupyterhub. Works on SRVX1 and JET. +