From dc93f57fe43f85d3297beded42d35000afbed60d Mon Sep 17 00:00:00 2001 From: Brian Vanderwende Date: Mon, 6 Feb 2023 11:53:29 -0700 Subject: [PATCH 1/2] Updates to HPC notebooks --- notebooks/05-dask-hpc.ipynb | 1341 ++++- notebooks/06-dask-chunking.ipynb | 8100 +++++++++++++++++++++++++++++- 2 files changed, 9290 insertions(+), 151 deletions(-) diff --git a/notebooks/05-dask-hpc.ipynb b/notebooks/05-dask-hpc.ipynb index e9e948f..2ad1732 100644 --- a/notebooks/05-dask-hpc.ipynb +++ b/notebooks/05-dask-hpc.ipynb @@ -55,7 +55,7 @@ "\n", "Using Dask on an HPC system is no different - we need to interact with the scheduler to provide Dask with ample compute resources. We *could* first start a job with multiple cores and a large amount of memory, and then use the **LocalCluster** to spawn workers. However, this approach only scales to a single node.\n", "\n", - "The typical approach is to let Dask request resources directly from the job scheduler via a scheduler-specific cluster type. Such clusters are provided by the add-on `dask-joqueue` package." + "The typical approach is to let Dask request resources directly from the job scheduler via a scheduler-specific cluster type. Such clusters are provided by the add-on `dask-jobqueue` package." ] }, { @@ -65,12 +65,12 @@ "source": [ "### Creating a scheduled-cluster\n", "\n", - "Since we use the PBS Pro scheduler at NCAR, we will use the **PBSCluster** Dask scheduler from `dask-joqueue`. Initialization is similar to a **LocalCluster**, but with unique parameters specific to creating batch jobs." + "Since we use the PBS Pro scheduler at NCAR, we will use the **PBSCluster** Dask scheduler from `dask-jobqueue`. Initialization is similar to a **LocalCluster**, but with unique parameters specific to creating batch jobs." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "d317a0ce-f1b8-47c5-8790-a9fd266ca248", "metadata": {}, "outputs": [], @@ -90,10 +90,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "4b0ecda0-2777-4fcd-a1a8-f3cd462f4fe6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/node.py:183: UserWarning: Port 8787 is already in use.\n", + "Perhaps you already have a cluster running?\n", + "Hosting the HTTP server on port 39174 instead\n", + " warnings.warn(\n" + ] + } + ], "source": [ "# Create a PBS cluster object\n", "cluster = PBSCluster(\n", @@ -132,7 +143,7 @@ "* Can speed up file-reads in some situations\n", "\n", "**Using more workers per job will:**\n", - "* Allow for multithreading speedups in thread-friendly workflows\n", + "* Less overhead in thread-friendly workflows\n", "* May allow for slightly higher memory thresholds since they will share a pool" ] }, @@ -146,10 +157,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "10475615-7181-4b46-b807-7e210d488c73", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#!/usr/bin/env bash\n", + "\n", + "#PBS -N dask-wk23-hpc\n", + "#PBS -q casper\n", + "#PBS -A SCSG0001\n", + "#PBS -l select=1:ncpus=1:mem=4GB\n", + "#PBS -l walltime=30:00\n", + "#PBS -e dask-worker-logs/\n", + "#PBS -o dask-worker-logs/\n", + "#PBS -j oe\n", + "\n", + "/glade/u/apps/opt/conda/envs/npl-2023a/bin/python -m distributed.cli.dask_worker tcp://10.12.206.46:36425 --nthreads 1 --memory-limit 4.00GiB --name dummy-name --nanny --death-timeout 60 --local-directory /local_scratch/pbs.$PBS_JOBID/dask/spill --interface ib0\n", + "\n" + ] + } + ], "source": [ "print(cluster.job_script())" ] @@ -187,20 +218,60 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "8a955a20-eeac-4ea9-8220-e7951fe18e05", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "distributed.yaml jobqueue.yaml labextension.yaml\n" + ] + } + ], "source": [ "!ls ~/.config/dask" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "7599a5e1-ffab-4a8f-9998-92e7dfc933ef", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'name': 'dask-worker',\n", + " 'cores': 1,\n", + " 'memory': '2GiB',\n", + " 'processes': 1,\n", + " 'interface': 'ib0',\n", + " 'death-timeout': 60,\n", + " 'local-directory': '/local_scratch/pbs.$PBS_JOBID/dask',\n", + " 'shared-temp-directory': None,\n", + " 'extra': None,\n", + " 'worker-extra-args': [],\n", + " 'shebang': '#!/usr/bin/env bash',\n", + " 'queue': 'casper',\n", + " 'account': 'SCSG0001',\n", + " 'walltime': '00:30:00',\n", + " 'env-extra': None,\n", + " 'job-script-prologue': [],\n", + " 'resource-spec': '-l select=1:ncpus=1:mem=2GB',\n", + " 'job-extra': None,\n", + " 'job-extra-directives': ['-j oe'],\n", + " 'job-directives-skip': [],\n", + " 'log-directory': 'dask-worker-logs',\n", + " 'scheduler-options': {}}" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Programmatically view configuration file(s) within Python\n", "from dask import config\n", @@ -215,7 +286,7 @@ "source": [ "### Live Performance Monitoring\n", "\n", - "Using `dask.distributed` provides us with a powerful diagnostic tool you have already seen: the *Dashboard*. The Dashboard can be integrated into your Jupyter environment in two ways - either with a separate website accessible from the Client widgit, or as tabs in your JupyterLab interface via the `dask-labextension` add-on.\n", + "Using `dask.distributed` provides us with a powerful diagnostic tool you have already seen: the *Dashboard*. The Dashboard can be integrated into your Jupyter environment in two ways - either with a separate website accessible from the Client widget, or as tabs in your JupyterLab interface via the `dask-labextension` add-on.\n", "\n", "**Tip:** JupyterLab Dashboard tabs can be saved as a \"workspace\" and loaded back in future sessions.\n", "\n", @@ -224,7 +295,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "d394abe8-d31b-454d-b3eb-dbf8ae16ddaa", "metadata": {}, "outputs": [], @@ -235,10 +306,135 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "44a153c2-129c-49fd-ba77-7d13fa5048c1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + "

Client

\n", + "

Client-c04bc201-a644-11ed-998a-3cecef1acb68

\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
Connection method: Cluster objectCluster type: dask_jobqueue.PBSCluster
\n", + " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/39174/status\n", + "
\n", + "\n", + " \n", + "
\n", + "

Cluster Info

\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

PBSCluster

\n", + "

ae77153c

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/39174/status\n", + " \n", + " Workers: 0\n", + "
\n", + " Total threads: 0\n", + " \n", + " Total memory: 0 B\n", + "
\n", + "\n", + "
\n", + " \n", + "

Scheduler Info

\n", + " \n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

Scheduler

\n", + "

Scheduler-c391f848-0c4a-4fdc-a1f6-e276dc799f1d

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Comm: tcp://10.12.206.46:36425\n", + " \n", + " Workers: 0\n", + "
\n", + " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/39174/status\n", + " \n", + " Total threads: 0\n", + "
\n", + " Started: 12 minutes ago\n", + " \n", + " Total memory: 0 B\n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "

Workers

\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Display the client repr\n", "client" @@ -254,7 +450,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "bc7cc604-dfe2-4d7e-b305-3d71ee64428e", "metadata": {}, "outputs": [], @@ -268,10 +464,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "0a45c3b5-aad4-45b1-978b-a2374e83f260", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "{'PBSCluster-1': ,\n", + " 'PBSCluster-0': }" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# See the workers from the cluster object\n", "cluster.workers" @@ -279,10 +487,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "ad5a6709-858a-4434-9403-56ffe7a04f2e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Req'd Req'd Elap\n", + "Job ID Username Queue Jobname SessID NDS TSK Memory Time S Time\n", + "--------------- -------- -------- ---------- ------ --- --- ------ ----- - -----\n", + "5525918.casper* vanderwb jhublog* cr-login-* 2269 1 1 4gb 720:0 R 68:43\n", + "5549560.casper* vanderwb htc dask-wk23* 83947 1 1 4gb 00:30 R 00:00\n", + "5549561.casper* vanderwb htc dask-wk23* 84096 1 1 4gb 00:30 R 00:00\n", + "\n", + "Cached at: Mon Feb 6 10:40:04 MST 2023\n" + ] + } + ], "source": [ "# See the workers in the job scheduler\n", "!qstat -u $USER" @@ -303,12 +526,12 @@ "source": [ "#### Dashboard demo: multi-file Xarray data analysis\n", "\n", - "To demonstrate how the Dashboard can be useful, let's do some simply analysis of data files using Xarray. Here we load 8 days of GOES5 data, and compute the mean near-surface temperature across the western US." + "To demonstrate how the Dashboard can be useful, let's do some simple analysis of data files using Xarray. Here we load 19 days of GOES5 data, and compute the mean near-surface temperature across the western US." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "a62fe240-c8bc-4857-9e03-7af100baa2cb", "metadata": {}, "outputs": [], @@ -318,7 +541,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "6d8edc52-70ad-4a20-ad41-3596838f621b", "metadata": {}, "outputs": [], @@ -329,10 +552,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "dcf1b6f7-3290-4ffb-a982-c5e209e482b0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Size of Variable = 33.86 GiB\n" + ] + } + ], "source": [ "# Show the total size of the variable (this has not been read in yet!)\n", "print(\"Size of Variable = {:5.2f} GiB\".format(ds.T.nbytes / 1024 ** 3))" @@ -348,10 +579,666 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "77a4042b-a3a2-4731-9ebb-33011337fecb", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'T' (time: 152, lev: 72, lat: 721, lon: 1152)>\n",
+       "dask.array<concatenate, shape=(152, 72, 721, 1152), dtype=float32, chunksize=(8, 72, 721, 1152), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * lon      (lon) float64 0.0 0.3125 0.625 0.9375 ... 358.8 359.1 359.4 359.7\n",
+       "  * lat      (lat) float64 -90.0 -89.75 -89.5 -89.25 ... 89.25 89.5 89.75 90.0\n",
+       "  * time     (time) datetime64[ns] 2022-01-01 ... 2022-01-19T21:00:00\n",
+       "  * lev      (lev) float32 0.015 0.02635 0.04014 0.05679 ... 962.5 977.5 992.5\n",
+       "Attributes:\n",
+       "    long_name:       air_temperature\n",
+       "    units:           K\n",
+       "    fmissing_value:  1000000000000000.0\n",
+       "    standard_name:   air_temperature\n",
+       "    vmax:            1000000000000000.0\n",
+       "    vmin:            -1000000000000000.0\n",
+       "    valid_range:     [-1.e+15  1.e+15]
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " * lon (lon) float64 0.0 0.3125 0.625 0.9375 ... 358.8 359.1 359.4 359.7\n", + " * lat (lat) float64 -90.0 -89.75 -89.5 -89.25 ... 89.25 89.5 89.75 90.0\n", + " * time (time) datetime64[ns] 2022-01-01 ... 2022-01-19T21:00:00\n", + " * lev (lev) float32 0.015 0.02635 0.04014 0.05679 ... 962.5 977.5 992.5\n", + "Attributes:\n", + " long_name: air_temperature\n", + " units: K\n", + " fmissing_value: 1000000000000000.0\n", + " standard_name: air_temperature\n", + " vmax: 1000000000000000.0\n", + " vmin: -1000000000000000.0\n", + " valid_range: [-1.e+15 1.e+15]" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# The graphical repr of one DaskArray - T\n", "ds.T" @@ -362,7 +1249,7 @@ "id": "37816544-50c9-42b2-835c-ce24a650f3c5", "metadata": {}, "source": [ - "It looks like our data will fit into RAM, but we can verify using the Dashboard. Let's construct our computation. Here we do the following:\n", + "It looks like our data chunks will fit into RAM, but we can verify using the Dashboard. Let's construct our computation. Here we do the following:\n", "1. Subset the \"western US\" from the data via lat/lon slices\n", "2. Take the mean of temperature values across our western US box\n", "3. Select the near-surface level (0)\n", @@ -372,7 +1259,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "0d37e389-3f74-4798-ae85-0a94f9b5c19f", "metadata": {}, "outputs": [], @@ -383,10 +1270,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "ee71e697-92c0-4832-9395-0864f3c7fac7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Tip - double-click the figure to see the actual size\n", "dask.visualize(sfc_mean_graph)" @@ -402,10 +1301,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "4b746a91-75cc-4173-9cc1-9a6d1afd6c38", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.3 s, sys: 131 ms, total: 1.43 s\n", + "Wall time: 34.8 s\n" + ] + } + ], "source": [ "%%time\n", "result = sfc_mean_graph.compute()" @@ -413,10 +1321,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "ab77998c-2fd0-4672-be8c-8fedd11660a4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "result.plot()" ] @@ -431,7 +1360,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "6c28c82e-e191-42ca-85ba-4a911a4ca50c", "metadata": {}, "outputs": [], @@ -443,10 +1372,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "0221d503-9bcd-4cd7-9999-8449bcf556b4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Req'd Req'd Elap\n", + "Job ID Username Queue Jobname SessID NDS TSK Memory Time S Time\n", + "--------------- -------- -------- ---------- ------ --- --- ------ ----- - -----\n", + "5525918.casper* vanderwb jhublog* cr-login-* 2269 1 1 4gb 720:0 R 68:51\n", + "5549560.casper* vanderwb htc dask-wk23* 83947 1 1 4gb 00:30 R 00:08\n", + "5549561.casper* vanderwb htc dask-wk23* 84096 1 1 4gb 00:30 R 00:08\n", + "5549594.casper* vanderwb htc dask-wk23* 97096 1 1 4gb 00:30 R 00:00\n", + "5549595.casper* vanderwb htc dask-wk23* 84490 1 1 4gb 00:30 R 00:00\n", + "\n", + "Cached at: Mon Feb 6 10:48:44 MST 2023\n" + ] + } + ], "source": [ "# How does this look in PBS?\n", "!qstat -u vanderwb" @@ -464,7 +1410,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "36abd4e9-4294-4eb9-a5e4-2f3d85a2f7c6", "metadata": {}, "outputs": [], @@ -475,14 +1421,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "2e4d4d5a-a3f8-4f8d-a3af-fd033c51f337", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 1.02 s, sys: 69.2 ms, total: 1.09 s\n", + "Wall time: 17.9 s\n" + ] + } + ], "source": [ "%%time\n", "# Since metrics are captured live anyway, the overhead from the report is small\n", - "with performance_report(filename=\"dask-pr.html\"):\n", + "with performance_report(filename=\"dask-report.html\"):\n", " result = sfc_mean_graph.compute()" ] }, @@ -498,7 +1453,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "c9a900c8-be09-4039-a95a-2617bcd463c3", "metadata": {}, "outputs": [], @@ -509,10 +1464,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "22bf9403-0186-46bd-8cd5-c0d613be6162", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 248 ms, sys: 9.44 ms, total: 258 ms\n", + "Wall time: 5.45 s\n" + ] + } + ], "source": [ "%%time\n", "result = sfc_mean_graph.compute()" @@ -533,7 +1497,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "0a2fd78d-e116-4e5b-95ad-a75e5e24b6d3", "metadata": {}, "outputs": [], @@ -544,10 +1508,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "7224a727-6873-4988-afcf-b4bf40182015", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 200 ms, sys: 14.8 ms, total: 215 ms\n", + "Wall time: 4.84 s\n" + ] + } + ], "source": [ "%%time\n", "result = sfc_mean_graph.compute()" @@ -565,10 +1538,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "3d727024-d802-46b0-8138-a08e6f118433", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "result.plot()" ] @@ -600,14 +1594,14 @@ "\n", "Sometimes you will need to compute multiple parameters on data from Dask objects. Using `.persist()` to store intermediate data in worker memory can save computational time if used appropriately. The raw data can be persisted too, of course, but watch out for exhausting worker memory.\n", "\n", - "Here we compare the time it takes - with and without persisting intermediate results - to compute our level-0 mean and a mean across all model levels.\n", + "Here we compare the time it takes - with and without persisting intermediate results - to compute our level-0 mean, a level-10 mean, and a mean across all model levels.\n", "\n", "We will also introduce another diagnostic tool here, the `MemorySampler` context manager." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "id": "767453d0-148b-4281-b767-5831569868f2", "metadata": {}, "outputs": [], @@ -618,10 +1612,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "id": "228524e0-3ffa-4740-a4a1-eaf9fc101c2c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 937 ms, sys: 81 ms, total: 1.02 s\n", + "Wall time: 25 s\n" + ] + } + ], "source": [ "%%time\n", "# Without persistance\n", @@ -633,10 +1636,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "39882b19-e745-4b44-a2c4-d19ffa662aa1", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 596 ms, sys: 44 ms, total: 640 ms\n", + "Wall time: 15.9 s\n" + ] + } + ], "source": [ "%%time\n", "# With persistance\n", @@ -659,10 +1671,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "4966cc57-42f6-4f81-9386-dc5c5dbe3043", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ms.plot(align=True)" ] @@ -679,7 +1712,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "id": "47eb05e6-f35e-473b-bed8-55e625d8b6f7", "metadata": {}, "outputs": [], @@ -689,7 +1722,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "aa1b4fb0-ed7e-48be-a8f4-550e5edbc415", "metadata": {}, "outputs": [], @@ -729,7 +1762,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "1c2a719a-6e10-4aa5-a267-9a320616643a", "metadata": {}, "outputs": [], @@ -750,7 +1783,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "55a817f6-6a9e-440d-b118-39ff99385cb6", "metadata": {}, "outputs": [], @@ -761,7 +1794,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "id": "a2eb9129-8105-4954-b00c-69c822f92bfc", "metadata": {}, "outputs": [], @@ -773,10 +1806,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "id": "46f1ea0c-63a1-4e6a-9c20-819592047235", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of 1600 MiB random array = 0.50\n", + "Mean of 2400 MiB random array = 0.50\n", + "Mean of 3200 MiB random array = 0.50\n" + ] + }, + { + "ename": "KilledWorker", + "evalue": "Attempted to run task ('random_sample-mean_chunk-fa2b790a89674d7f8b087dd85b1f120d', 0) on 3 different workers, but all those workers died while running it. The last worker that attempt to run the task was tcp://10.12.206.32:39212. Inspecting worker logs is often a good next step to diagnose what went wrong. For more information see https://distributed.dask.org/en/stable/killed.html.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKilledWorker\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[37], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m client\u001b[38;5;241m.\u001b[39mrun(log_message, chunk_mib)\n\u001b[1;32m 3\u001b[0m chunk_size \u001b[38;5;241m=\u001b[39m chunk_mib \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m8\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m1024\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m1024\u001b[39m\n\u001b[0;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMean of \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m MiB random array = \u001b[39m\u001b[38;5;132;01m{:0.2f}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(chunk_mib, \u001b[43mda\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchunk_size\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchunks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mchunk_size\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmean\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompute\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m))\n", + "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/dask/base.py:315\u001b[0m, in \u001b[0;36mDaskMethodsMixin.compute\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 291\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompute\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 292\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Compute this dask collection\u001b[39;00m\n\u001b[1;32m 293\u001b[0m \n\u001b[1;32m 294\u001b[0m \u001b[38;5;124;03m This turns a lazy Dask collection into its in-memory equivalent.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 313\u001b[0m \u001b[38;5;124;03m dask.base.compute\u001b[39;00m\n\u001b[1;32m 314\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 315\u001b[0m (result,) \u001b[38;5;241m=\u001b[39m \u001b[43mcompute\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtraverse\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 316\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/dask/base.py:600\u001b[0m, in \u001b[0;36mcompute\u001b[0;34m(traverse, optimize_graph, scheduler, get, *args, **kwargs)\u001b[0m\n\u001b[1;32m 597\u001b[0m keys\u001b[38;5;241m.\u001b[39mappend(x\u001b[38;5;241m.\u001b[39m__dask_keys__())\n\u001b[1;32m 598\u001b[0m postcomputes\u001b[38;5;241m.\u001b[39mappend(x\u001b[38;5;241m.\u001b[39m__dask_postcompute__())\n\u001b[0;32m--> 600\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mschedule\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdsk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 601\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m repack([f(r, \u001b[38;5;241m*\u001b[39ma) \u001b[38;5;28;01mfor\u001b[39;00m r, (f, a) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(results, postcomputes)])\n", + "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/client.py:3057\u001b[0m, in \u001b[0;36mClient.get\u001b[0;34m(self, dsk, keys, workers, allow_other_workers, resources, sync, asynchronous, direct, retries, priority, fifo_timeout, actors, **kwargs)\u001b[0m\n\u001b[1;32m 3055\u001b[0m should_rejoin \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m 3056\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 3057\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgather\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpacked\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43masynchronous\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43masynchronous\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdirect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdirect\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3058\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 3059\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m f \u001b[38;5;129;01min\u001b[39;00m futures\u001b[38;5;241m.\u001b[39mvalues():\n", + "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/client.py:2226\u001b[0m, in \u001b[0;36mClient.gather\u001b[0;34m(self, futures, errors, direct, asynchronous)\u001b[0m\n\u001b[1;32m 2224\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 2225\u001b[0m local_worker \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 2226\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msync\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2227\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_gather\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2228\u001b[0m \u001b[43m \u001b[49m\u001b[43mfutures\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2229\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2230\u001b[0m \u001b[43m \u001b[49m\u001b[43mdirect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdirect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2231\u001b[0m \u001b[43m \u001b[49m\u001b[43mlocal_worker\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlocal_worker\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2232\u001b[0m \u001b[43m \u001b[49m\u001b[43masynchronous\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43masynchronous\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2233\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/utils.py:339\u001b[0m, in \u001b[0;36mSyncMethodMixin.sync\u001b[0;34m(self, func, asynchronous, callback_timeout, *args, **kwargs)\u001b[0m\n\u001b[1;32m 337\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m future\n\u001b[1;32m 338\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 339\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msync\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 340\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallback_timeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallback_timeout\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 341\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/utils.py:406\u001b[0m, in \u001b[0;36msync\u001b[0;34m(loop, func, callback_timeout, *args, **kwargs)\u001b[0m\n\u001b[1;32m 404\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m error:\n\u001b[1;32m 405\u001b[0m typ, exc, tb \u001b[38;5;241m=\u001b[39m error\n\u001b[0;32m--> 406\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\u001b[38;5;241m.\u001b[39mwith_traceback(tb)\n\u001b[1;32m 407\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 408\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/utils.py:379\u001b[0m, in \u001b[0;36msync..f\u001b[0;34m()\u001b[0m\n\u001b[1;32m 377\u001b[0m future \u001b[38;5;241m=\u001b[39m asyncio\u001b[38;5;241m.\u001b[39mwait_for(future, callback_timeout)\n\u001b[1;32m 378\u001b[0m future \u001b[38;5;241m=\u001b[39m asyncio\u001b[38;5;241m.\u001b[39mensure_future(future)\n\u001b[0;32m--> 379\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01myield\u001b[39;00m future\n\u001b[1;32m 380\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 381\u001b[0m error \u001b[38;5;241m=\u001b[39m sys\u001b[38;5;241m.\u001b[39mexc_info()\n", + "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/tornado/gen.py:762\u001b[0m, in \u001b[0;36mRunner.run\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 759\u001b[0m exc_info \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 761\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 762\u001b[0m value \u001b[38;5;241m=\u001b[39m \u001b[43mfuture\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresult\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 763\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 764\u001b[0m exc_info \u001b[38;5;241m=\u001b[39m sys\u001b[38;5;241m.\u001b[39mexc_info()\n", + "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/client.py:2089\u001b[0m, in \u001b[0;36mClient._gather\u001b[0;34m(self, futures, errors, direct, local_worker)\u001b[0m\n\u001b[1;32m 2087\u001b[0m exc \u001b[38;5;241m=\u001b[39m CancelledError(key)\n\u001b[1;32m 2088\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 2089\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exception\u001b[38;5;241m.\u001b[39mwith_traceback(traceback)\n\u001b[1;32m 2090\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\n\u001b[1;32m 2091\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m errors \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mskip\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n", + "\u001b[0;31mKilledWorker\u001b[0m: Attempted to run task ('random_sample-mean_chunk-fa2b790a89674d7f8b087dd85b1f120d', 0) on 3 different workers, but all those workers died while running it. The last worker that attempt to run the task was tcp://10.12.206.32:39212. Inspecting worker logs is often a good next step to diagnose what went wrong. For more information see https://distributed.dask.org/en/stable/killed.html." + ] + } + ], "source": [ "for chunk_mib in [1600, 2400, 3200, 3900]:\n", " client.run(log_message, chunk_mib)\n", @@ -786,10 +1849,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "id": "456149fc-3fe5-482b-83bb-8d0ab5f11673", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-rw-r--r-- 1 vanderwb csgteam 24446 Feb 6 11:11 5549719.casper-pbs.OU\n", + "-rw-r--r-- 1 vanderwb csgteam 24452 Feb 6 11:11 5549721.casper-pbs.OU\n", + "-rw-r--r-- 1 vanderwb csgteam 24099 Feb 6 11:11 5549720.casper-pbs.OU\n", + "-rw-r--r-- 1 vanderwb csgteam 24446 Feb 6 11:11 5549718.casper-pbs.OU\n" + ] + } + ], "source": [ "# List the most recent 4 worker logs - these should be our logs\n", "!ls -lrt dask-worker-logs | tail -n 4" @@ -805,10 +1879,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "id": "ee6e1e52-9078-4bf5-8c03-edabbfbb7629", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Req'd Req'd Elap\n", + "Job ID Username Queue Jobname SessID NDS TSK Memory Time S Time\n", + "--------------- -------- -------- ---------- ------ --- --- ------ ----- - -----\n", + "5525918.casper* vanderwb jhublog* cr-login-* 2269 1 1 4gb 720:0 R 69:17\n", + "5549718.casper* vanderwb htc dask-wk23* 94402 1 1 4gb 00:30 R 00:04\n", + "5549719.casper* vanderwb htc dask-wk23* 94285 1 1 4gb 00:30 R 00:04\n", + "5549720.casper* vanderwb htc dask-wk23* 197151 1 1 4gb 00:30 R 00:04\n", + "5549721.casper* vanderwb htc dask-wk23* 197196 1 1 4gb 00:30 R 00:04\n", + "\n", + "Cached at: Mon Feb 6 11:15:35 MST 2023\n" + ] + } + ], "source": [ "# Let's look at the worker state in PBS after the failure\n", "!qstat -u vanderwb" @@ -828,7 +1919,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "id": "ec0635f9-8b2c-44b4-86f7-0d35b6765242", "metadata": {}, "outputs": [], @@ -857,10 +1948,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "id": "e848ef4b-a28d-472a-98a0-27f75254e8ab", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'dask-wk23-hpc'" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "cluster.job_name" ] @@ -883,7 +1985,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "id": "0e2b5bd8-96d7-4180-b1b7-f491cab24804", "metadata": {}, "outputs": [], @@ -893,10 +1995,85 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "id": "730c5d64-0567-464e-87af-63840f878ed6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Job IDNCPUsElapsed (h)
05526022.casper-pbs10.05
15526023.casper-pbs10.05
25526025.casper-pbs10.05
35526024.casper-pbs10.05
45525958.casper-pbs10.25
\n", + "
" + ], + "text/plain": [ + " Job ID NCPUs Elapsed (h)\n", + "0 5526022.casper-pbs 1 0.05\n", + "1 5526023.casper-pbs 1 0.05\n", + "2 5526025.casper-pbs 1 0.05\n", + "3 5526024.casper-pbs 1 0.05\n", + "4 5525958.casper-pbs 1 0.25" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "dj = pd.read_csv(\"../data/qhist-dask.out\")\n", "dj.head()" @@ -904,10 +2081,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "id": "d766238b-6d3a-4aa3-85c5-71802d86a0d7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Core-hours used by this notebook: 1.12\n" + ] + } + ], "source": [ "print(\"Core-hours used by this notebook: {:.2f}\".format(sum(dj['NCPUs'] * dj['Elapsed (h)'])))" ] diff --git a/notebooks/06-dask-chunking.ipynb b/notebooks/06-dask-chunking.ipynb index 6f39e6e..23e0bd3 100644 --- a/notebooks/06-dask-chunking.ipynb +++ b/notebooks/06-dask-chunking.ipynb @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "d317a0ce-f1b8-47c5-8790-a9fd266ca248", "metadata": {}, "outputs": [], @@ -90,10 +90,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "4b0ecda0-2777-4fcd-a1a8-f3cd462f4fe6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/node.py:183: UserWarning: Port 8787 is already in use.\n", + "Perhaps you already have a cluster running?\n", + "Hosting the HTTP server on port 42815 instead\n", + " warnings.warn(\n" + ] + } + ], "source": [ "# Create a PBS cluster object\n", "cluster = PBSCluster(\n", @@ -111,10 +122,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "10475615-7181-4b46-b807-7e210d488c73", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#!/usr/bin/env bash\n", + "\n", + "#PBS -N dask-wk23-chunking\n", + "#PBS -q casper\n", + "#PBS -A SCSG0001\n", + "#PBS -l select=1:ncpus=1:mem=10GB\n", + "#PBS -l walltime=30:00\n", + "#PBS -e dask-worker-logs/\n", + "#PBS -o dask-worker-logs/\n", + "#PBS -j oe\n", + "\n", + "/glade/u/apps/opt/conda/envs/npl-2023a/bin/python -m distributed.cli.dask_worker tcp://10.12.206.46:41979 --nthreads 1 --memory-limit 10.00GiB --name dummy-name --nanny --death-timeout 60 --local-directory /glade/scratch/vanderwb/temp/dask/spill/pbs.$PBS_JOBID --interface ib0\n", + "\n" + ] + } + ], "source": [ "# Sanity-check our setup\n", "print(cluster.job_script())" @@ -122,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "107629fa-34a3-426c-828e-bafe6a8d7ca2", "metadata": { "tags": [] @@ -134,10 +165,135 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "c82f23a4-a8f3-412e-b511-7b2f2c96c552", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + "

Client

\n", + "

Client-0c11bd37-a64c-11ed-affc-3cecef1acb68

\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
Connection method: Cluster objectCluster type: dask_jobqueue.PBSCluster
\n", + " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/42815/status\n", + "
\n", + "\n", + " \n", + "
\n", + "

Cluster Info

\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

PBSCluster

\n", + "

d23f7926

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/42815/status\n", + " \n", + " Workers: 0\n", + "
\n", + " Total threads: 0\n", + " \n", + " Total memory: 0 B\n", + "
\n", + "\n", + "
\n", + " \n", + "

Scheduler Info

\n", + " \n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + "

Scheduler

\n", + "

Scheduler-e70f971e-6622-432c-ad59-8515b1fd81f5

\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " Comm: tcp://10.12.206.46:41979\n", + " \n", + " Workers: 0\n", + "
\n", + " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/42815/status\n", + " \n", + " Total threads: 0\n", + "
\n", + " Started: Just now\n", + " \n", + " Total memory: 0 B\n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "

Workers

\n", + " \n", + "\n", + " \n", + "\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + "
\n", + " \n", + "\n", + "
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "client" ] @@ -171,7 +327,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "dbb9aa86-182b-4ca6-bf62-d8a7884b0306", "metadata": {}, "outputs": [], @@ -191,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "7efdf2dc-2d99-43ad-a0a6-a3aa71049e1e", "metadata": {}, "outputs": [], @@ -201,10 +357,83 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "d9d2aa49-94d0-4cd1-bc28-db3aef3815d5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Array Chunk
Bytes 32.19 GiB 8.05 GiB
Shape (60000, 72000) (30000, 36000)
Count 1 Graph Layer 4 Chunks
Type float64 numpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 72000\n", + " 60000\n", + "\n", + "
" + ], + "text/plain": [ + "dask.array" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "t = da.random.random((60000, 72000), chunks = (30000,36000))\n", "t" @@ -220,10 +449,316 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "47da0213-4c7e-483e-99a3-73393559c817", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "

HighLevelGraph

\n", + "

\n", + " HighLevelGraph with 3 layers and 9 keys from all layers.\n", + "

\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer1: random_sample

\n", + " \n", + "

\n", + " random_sample-99d384ebf7643e046beb2659e21d477c\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs4
shape(60000, 72000)
dtypefloat64
chunksize(30000, 36000)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 72000\n", + " 60000\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer2: mean_chunk

\n", + " \n", + "

\n", + " mean_chunk-1db7ddb1bae521842cca9af0d431c4c5\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs4
shape(60000, 72000)
dtypefloat64
chunksize(30000, 36000)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-99d384ebf7643e046beb2659e21d477c
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 72000\n", + " 60000\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer3: mean_agg-aggregate

\n", + " \n", + "

\n", + " mean_agg-aggregate-b00133a3cd939d8bebad9aae1408daf7\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_chunk-1db7ddb1bae521842cca9af0d431c4c5
\n", + " 		\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
" + ], + "text/plain": [ + "HighLevelGraph with 3 layers.\n", + "\n", + " 0. random_sample-99d384ebf7643e046beb2659e21d477c\n", + " 1. mean_chunk-1db7ddb1bae521842cca9af0d431c4c5\n", + " 2. mean_agg-aggregate-b00133a3cd939d8bebad9aae1408daf7" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "task = t.mean()\n", "task.dask" @@ -231,10 +766,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "d74ce6b4-88d3-495e-8b54-66d69b68a614", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 608 ms, sys: 143 ms, total: 751 ms\n", + "Wall time: 10.4 s\n" + ] + } + ], "source": [ "%%time\n", "result = task.compute()" @@ -250,10 +794,117 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "552aa90c-908d-42ca-bcad-bfad2e8022ef", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Array Chunk
Bytes 32.19 GiB 7.63 MiB
Shape (60000, 72000) (1000, 1000)
Count 1 Graph Layer 4320 Chunks
Type float64 numpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 72000\n", + " 60000\n", + "\n", + "
" + ], + "text/plain": [ + "dask.array" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "t = da.random.random((60000, 72000), chunks = (1000,1000))\n", "t" @@ -261,10 +912,1129 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "57a139e9-ecf6-45d8-a3de-cf7d2561b8a6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "

HighLevelGraph

\n", + "

\n", + " HighLevelGraph with 9 layers and 10091 keys from all layers.\n", + "

\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer1: random_sample

\n", + " \n", + "

\n", + " random_sample-d864cc98d7b0c810e3981396d0a31505\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs4320
shape(60000, 72000)
dtypefloat64
chunksize(1000, 1000)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 72000\n", + " 60000\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer2: mean_chunk

\n", + " \n", + "

\n", + " mean_chunk-2d6be3ffa6620a03b940271bbcfde966\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs4320
shape(60000, 72000)
dtypefloat64
chunksize(1000, 1000)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-d864cc98d7b0c810e3981396d0a31505
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 72000\n", + " 60000\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer3: mean_combine-partial

\n", + " \n", + "

\n", + " mean_combine-partial-29b2186694d79f2d7731b08940ea330c\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1080
shape(30, 36)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_chunk-2d6be3ffa6620a03b940271bbcfde966
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 36\n", + " 30\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer4: mean_combine-partial

\n", + " \n", + "

\n", + " mean_combine-partial-58ad99c24bbf255733617407d84da342\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs270
shape(15, 18)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-29b2186694d79f2d7731b08940ea330c
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 18\n", + " 15\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer5: mean_combine-partial

\n", + " \n", + "

\n", + " mean_combine-partial-455a2b59687d27f757814666f78b9772\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs72
shape(8, 9)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-58ad99c24bbf255733617407d84da342
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 9\n", + " 8\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer6: mean_combine-partial

\n", + " \n", + "

\n", + " mean_combine-partial-6cd2c59ea14367c391f8098f19de908a\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs20
shape(4, 5)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-455a2b59687d27f757814666f78b9772
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 5\n", + " 4\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer7: mean_combine-partial

\n", + " \n", + "

\n", + " mean_combine-partial-ae112b9d4ead8774877687e1fe1a34f6\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs6
shape(2, 3)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-6cd2c59ea14367c391f8098f19de908a
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 3\n", + " 2\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer8: mean_combine-partial

\n", + " \n", + "

\n", + " mean_combine-partial-0e2db5ea9697d821664c1bb0b1bc891f\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs2
shape(1, 2)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-ae112b9d4ead8774877687e1fe1a34f6
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 2\n", + " 1\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer9: mean_agg-aggregate

\n", + " \n", + "

\n", + " mean_agg-aggregate-2ed8945b01b8b27bf89378b4d820bdf5\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-0e2db5ea9697d821664c1bb0b1bc891f
\n", + " 		\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
" + ], + "text/plain": [ + "HighLevelGraph with 9 layers.\n", + "\n", + " 0. random_sample-d864cc98d7b0c810e3981396d0a31505\n", + " 1. mean_chunk-2d6be3ffa6620a03b940271bbcfde966\n", + " 2. mean_combine-partial-29b2186694d79f2d7731b08940ea330c\n", + " 3. mean_combine-partial-58ad99c24bbf255733617407d84da342\n", + " 4. mean_combine-partial-455a2b59687d27f757814666f78b9772\n", + " 5. mean_combine-partial-6cd2c59ea14367c391f8098f19de908a\n", + " 6. mean_combine-partial-ae112b9d4ead8774877687e1fe1a34f6\n", + " 7. mean_combine-partial-0e2db5ea9697d821664c1bb0b1bc891f\n", + " 8. mean_agg-aggregate-2ed8945b01b8b27bf89378b4d820bdf5" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "task = t.mean()\n", "task.dask" @@ -272,10 +2042,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "3c72dedb-2ea7-4d8a-8c90-479a9492694c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 5.78 s, sys: 262 ms, total: 6.04 s\n", + "Wall time: 12.8 s\n" + ] + } + ], "source": [ "%%time\n", "result = task.compute()" @@ -291,10 +2070,97 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "4bbedf51-7548-477d-bdda-b451b7be27c9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Array Chunk
Bytes 32.19 GiB 457.76 MiB
Shape (60000, 72000) (10000, 6000)
Count 1 Graph Layer 72 Chunks
Type float64 numpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 72000\n", + " 60000\n", + "\n", + "
" + ], + "text/plain": [ + "dask.array" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "t = da.random.random((60000, 72000), chunks = (10000,6000))\n", "t" @@ -302,10 +2168,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "1882a526-d8fd-4406-8bc4-4acc9b666739", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 796 ms, sys: 35.3 ms, total: 831 ms\n", + "Wall time: 9.39 s\n" + ] + } + ], "source": [ "%%time\n", "result = t.mean().compute()" @@ -331,7 +2206,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "d0eedce9-d0df-4235-bcff-6152cfde17da", "metadata": {}, "outputs": [], @@ -349,7 +2224,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "16bdef3e-6c2c-4007-b061-04aa85e052e6", "metadata": {}, "outputs": [], @@ -367,10 +2242,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "442f91b0-a174-467c-9095-0bf0e67639fe", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "( (unlimited): name = 'Time', size = 8,\n", + " : name = 'num_metgrid_levels', size = 34,\n", + " : name = 'south_north', size = 720,\n", + " : name = 'west_east', size = 720)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "nc_data = nc.Dataset(my_file)\n", "nc_data['CLDFRA'].get_dims()" @@ -386,10 +2275,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "82965dea-3b73-492a-b013-1f1e363cb9d8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 16, 355, 355]" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "nc_data['CLDFRA'].chunking()" ] @@ -406,7 +2306,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "d67ca1a2-3102-4f85-b44c-3a001a93e5d5", "metadata": {}, "outputs": [], @@ -416,7 +2316,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, "id": "bf1c6563-00f9-47ed-8e6c-1dcc5f7b0a85", "metadata": {}, "outputs": [], @@ -442,10 +2342,638 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "94a41e94-fafb-4d0e-9988-2569a1f9ef6f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'CLDFRA' (Time: 8, num_metgrid_levels: 34, south_north: 720,\n",
+       "                            west_east: 720)>\n",
+       "dask.array<open_dataset-2d5c51faf2dc21d9877d4227a4fb805dCLDFRA, shape=(8, 34, 720, 720), dtype=float32, chunksize=(1, 34, 720, 720), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * Time     (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n",
+       "    XLAT     (south_north, west_east) float32 dask.array<chunksize=(720, 720), meta=np.ndarray>\n",
+       "    XLONG    (south_north, west_east) float32 dask.array<chunksize=(720, 720), meta=np.ndarray>\n",
+       "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n",
+       "Attributes:\n",
+       "    FieldType:    104\n",
+       "    MemoryOrder:  XYZ\n",
+       "    units:        1.0\n",
+       "    stagger:      \n",
+       "    long_name:    CLOUD FRACTION
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " * Time (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n", + " XLAT (south_north, west_east) float32 dask.array\n", + " XLONG (south_north, west_east) float32 dask.array\n", + "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n", + "Attributes:\n", + " FieldType: 104\n", + " MemoryOrder: XYZ\n", + " units: 1.0\n", + " stagger: \n", + " long_name: CLOUD FRACTION" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "ds.CLDFRA" ] @@ -460,10 +2988,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "f541f89c-b2f8-49c7-aa93-70ef0bf8df9f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 16, 355, 355)" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "ds.CLDFRA.encoding[\"chunksizes\"]" ] @@ -480,10 +3019,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "48125db1-00ac-4600-a786-7e6e6cb098b7", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 163 ms, sys: 28.7 ms, total: 192 ms\n", + "Wall time: 1.73 s\n" + ] + } + ], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -499,21 +3047,671 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "e975b1ff-6c30-4270-ae2b-b945d96c02a0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'CLDFRA' (Time: 8, num_metgrid_levels: 34, south_north: 720,\n",
+       "                            west_east: 720)>\n",
+       "dask.array<open_dataset-a2a8daca35d216b566b6c638540eeed3CLDFRA, shape=(8, 34, 720, 720), dtype=float32, chunksize=(1, 16, 355, 720), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * Time     (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n",
+       "    XLAT     (south_north, west_east) float32 dask.array<chunksize=(355, 720), meta=np.ndarray>\n",
+       "    XLONG    (south_north, west_east) float32 dask.array<chunksize=(355, 720), meta=np.ndarray>\n",
+       "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n",
+       "Attributes:\n",
+       "    FieldType:    104\n",
+       "    MemoryOrder:  XYZ\n",
+       "    units:        1.0\n",
+       "    stagger:      \n",
+       "    long_name:    CLOUD FRACTION
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " * Time (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n", + " XLAT (south_north, west_east) float32 dask.array\n", + " XLONG (south_north, west_east) float32 dask.array\n", + "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n", + "Attributes:\n", + " FieldType: 104\n", + " MemoryOrder: XYZ\n", + " units: 1.0\n", + " stagger: \n", + " long_name: CLOUD FRACTION" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "ds = xr.open_dataset(my_file, chunks = {'Time' : 1, \"num_metgrid_levels\" : 16,\n", - " \"south_north\" : 355, \"east_west\" : 355})" + " \"south_north\" : 355, \"east_west\" : 355})\n", + "ds.CLDFRA" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "id": "b9257791-d82e-4564-bfe4-909e9253af3e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 171 ms, sys: 34.8 ms, total: 206 ms\n", + "Wall time: 1.25 s\n" + ] + } + ], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -529,7 +3727,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "3ab203f6-20a9-4183-b95c-2e119b40f217", "metadata": {}, "outputs": [], @@ -540,10 +3738,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "3af94486-17c3-43a8-8bbf-e82cd99cd8c0", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 202 ms, sys: 30.5 ms, total: 233 ms\n", + "Wall time: 2.44 s\n" + ] + } + ], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -551,7 +3758,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "ea3d0289-a14d-490d-a05e-5b43b3e80091", "metadata": {}, "outputs": [], @@ -562,10 +3769,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "id": "01f33087-5468-48a0-a3c0-9dfbced66f49", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 290 ms, sys: 40.4 ms, total: 330 ms\n", + "Wall time: 4.09 s\n" + ] + } + ], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -581,7 +3797,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "id": "82a204b9-95db-4516-a16e-56f30f3d98a6", "metadata": {}, "outputs": [], @@ -592,20 +3808,657 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "id": "0857d634-18cc-4f1f-98fe-b18007dd9394", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'CLDFRA' (Time: 8, num_metgrid_levels: 34, south_north: 720,\n",
+       "                            west_east: 720)>\n",
+       "dask.array<open_dataset-2475367054d27aaab126f113eb08b50aCLDFRA, shape=(8, 34, 720, 720), dtype=float32, chunksize=(5, 23, 539, 539), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * Time     (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n",
+       "    XLAT     (south_north, west_east) float32 dask.array<chunksize=(720, 720), meta=np.ndarray>\n",
+       "    XLONG    (south_north, west_east) float32 dask.array<chunksize=(720, 720), meta=np.ndarray>\n",
+       "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n",
+       "Attributes:\n",
+       "    FieldType:    104\n",
+       "    MemoryOrder:  XYZ\n",
+       "    units:        1.0\n",
+       "    stagger:      \n",
+       "    long_name:    CLOUD FRACTION
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " * Time (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n", + " XLAT (south_north, west_east) float32 dask.array\n", + " XLONG (south_north, west_east) float32 dask.array\n", + "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n", + "Attributes:\n", + " FieldType: 104\n", + " MemoryOrder: XYZ\n", + " units: 1.0\n", + " stagger: \n", + " long_name: CLOUD FRACTION" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "ds.CLDFRA" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "id": "04ad72d7-9b25-4516-8cbb-9c5068a881cc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 239 ms, sys: 47.5 ms, total: 287 ms\n", + "Wall time: 2.94 s\n" + ] + } + ], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -641,7 +4494,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "id": "c6f62d6e-2c35-4298-a546-e570a6736f28", "metadata": {}, "outputs": [], @@ -651,17 +4504,170 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "id": "ee642dae-b1c1-4aa2-873c-ab207be5fb5c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Array Chunk
Bytes 4.29 GiB 27.47 MiB
Shape (800, 600, 60, 20) (400, 300, 30, 1)
Count 1 Graph Layer 160 Chunks
Type float64 numpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
" + ], + "text/plain": [ + "dask.array" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "old_run" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 42, "id": "682d897a-4158-49ae-8960-7eac3b67c685", "metadata": {}, "outputs": [], @@ -671,10 +4677,168 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "id": "2e045450-a2a8-49b3-9ada-e9af425ebae2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Array Chunk
Bytes 4.29 GiB 36.62 MiB
Shape (800, 600, 60, 20) (800, 600, 10, 1)
Count 1 Graph Layer 120 Chunks
Type float64 numpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
" + ], + "text/plain": [ + "dask.array" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "new_run" ] @@ -689,7 +4853,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 44, "id": "7f773a71-37db-4023-ac13-81e7d19dba5e", "metadata": {}, "outputs": [], @@ -700,10 +4864,2069 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 45, "id": "b005b366-dc3b-431b-b381-7dc26c79fee6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "

HighLevelGraph

\n", + "

\n", + " HighLevelGraph with 13 layers and 3687 keys from all layers.\n", + "

\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer1: random_sample

\n", + " \n", + "

\n", + " random_sample-fd9ba15cb13072de19fd66472e82d66b\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer2: rechunk-merge

\n", + " \n", + "

\n", + " rechunk-merge-9a66792bcfd5f5b508140f8ea4b26a3f\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs960
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-fd9ba15cb13072de19fd66472e82d66b
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer3: random_sample

\n", + " \n", + "

\n", + " random_sample-535b0047aedf555ae5ae35ecd2323a7e\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs160
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 30, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer4: rechunk-merge

\n", + " \n", + "

\n", + " rechunk-merge-9802ca0e00bd1f84b6fc89883f52f318\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs960
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-535b0047aedf555ae5ae35ecd2323a7e
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer5: sub

\n", + " \n", + "

\n", + " sub-d87b5b362e8c84d54f59b448e01dd77b\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs480
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on rechunk-merge-9a66792bcfd5f5b508140f8ea4b26a3f
rechunk-merge-9802ca0e00bd1f84b6fc89883f52f318
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer6: pow

\n", + " \n", + "

\n", + " pow-ab7ec7709815938f98b9bf2bdce1836a\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs480
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sub-d87b5b362e8c84d54f59b448e01dd77b
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer7: sum

\n", + " \n", + "

\n", + " sum-a53d3bfee6626a55a4eda85b50dfe049\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs480
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on pow-ab7ec7709815938f98b9bf2bdce1836a
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer8: sum-partial

\n", + " \n", + "

\n", + " sum-partial-b3ab311847964dd7cac6fb2f34b5db40\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs30
shape(1, 1, 3, 10)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-a53d3bfee6626a55a4eda85b50dfe049
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 1\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 10\n", + " 3\n", + " 1\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer9: sum-partial

\n", + " \n", + "

\n", + " sum-partial-829816d4fdb725fc7f1c3608e4686ee8\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs10
shape(1, 1, 2, 5)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-b3ab311847964dd7cac6fb2f34b5db40
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 1\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 5\n", + " 2\n", + " 1\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer10: sum-partial

\n", + " \n", + "

\n", + " sum-partial-3ff45aea451de0539764b9222b4052ba\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs3
shape(1, 1, 1, 3)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-829816d4fdb725fc7f1c3608e4686ee8
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 1\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 3\n", + " 1\n", + " 1\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer11: sum-partial

\n", + " \n", + "

\n", + " sum-partial-01f450840da28991af2a3b2f763a53e8\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs2
shape(1, 1, 1, 2)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-3ff45aea451de0539764b9222b4052ba
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 1\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 2\n", + " 1\n", + " 1\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer12: sum-aggregate

\n", + " \n", + "

\n", + " sum-aggregate-4af89c3f0415d5889957431839e67b35\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-01f450840da28991af2a3b2f763a53e8
\n", + " 		\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer13: truediv

\n", + " \n", + "

\n", + " truediv-566720733aec6deed737e048a7eceb43\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-aggregate-4af89c3f0415d5889957431839e67b35
\n", + " 		\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
" + ], + "text/plain": [ + "HighLevelGraph with 13 layers.\n", + "\n", + " 0. random_sample-fd9ba15cb13072de19fd66472e82d66b\n", + " 1. rechunk-merge-9a66792bcfd5f5b508140f8ea4b26a3f\n", + " 2. random_sample-535b0047aedf555ae5ae35ecd2323a7e\n", + " 3. rechunk-merge-9802ca0e00bd1f84b6fc89883f52f318\n", + " 4. sub-d87b5b362e8c84d54f59b448e01dd77b\n", + " 5. pow-ab7ec7709815938f98b9bf2bdce1836a\n", + " 6. sum-a53d3bfee6626a55a4eda85b50dfe049\n", + " 7. sum-partial-b3ab311847964dd7cac6fb2f34b5db40\n", + " 8. sum-partial-829816d4fdb725fc7f1c3608e4686ee8\n", + " 9. sum-partial-3ff45aea451de0539764b9222b4052ba\n", + " 10. sum-partial-01f450840da28991af2a3b2f763a53e8\n", + " 11. sum-aggregate-4af89c3f0415d5889957431839e67b35\n", + " 12. truediv-566720733aec6deed737e048a7eceb43" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "mse_graph.dask" ] @@ -718,10 +6941,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 46, "id": "71844b87-19f7-4b9a-8ae3-54c8fafbea8d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 2.09 s, sys: 81.1 ms, total: 2.17 s\n", + "Wall time: 6.03 s\n" + ] + }, + { + "data": { + "text/plain": [ + "0.16667671401503523" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "%%time\n", "mse_graph.compute()" @@ -745,7 +6987,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 47, "id": "868a4114-6c60-4078-b6ea-45345702805d", "metadata": {}, "outputs": [], @@ -755,7 +6997,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "id": "3dc6ff9e-0199-4bdf-90f9-90e3de1ea516", "metadata": {}, "outputs": [], @@ -766,25 +7008,1737 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "id": "fc2cbe54-fa8b-4850-893d-be2874adf7ae", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "
\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + "
\n", + "

HighLevelGraph

\n", + "

\n", + " HighLevelGraph with 11 layers and 647 keys from all layers.\n", + "

\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer1: random_sample

\n", + " \n", + "

\n", + " random_sample-fd9ba15cb13072de19fd66472e82d66b\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer2: random_sample

\n", + " \n", + "

\n", + " random_sample-d33fff662d9857f9295d0807ee4a599e\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer3: sub

\n", + " \n", + "

\n", + " sub-4ba45aefc017b35e78ba2b9912547e10\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-fd9ba15cb13072de19fd66472e82d66b
random_sample-d33fff662d9857f9295d0807ee4a599e
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer4: pow

\n", + " \n", + "

\n", + " pow-f301b90316782c72884ebae330cbf967\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sub-4ba45aefc017b35e78ba2b9912547e10
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer5: sum

\n", + " \n", + "

\n", + " sum-28891e8622913ca84905020d6916a344\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on pow-f301b90316782c72884ebae330cbf967
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 800\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 20\n", + " 60\n", + " 600\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer6: sum-partial

\n", + " \n", + "

\n", + " sum-partial-195ddba553c92b5e66219e1973236728\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs30
shape(1, 1, 3, 10)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-28891e8622913ca84905020d6916a344
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 1\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 10\n", + " 3\n", + " 1\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer7: sum-partial

\n", + " \n", + "

\n", + " sum-partial-949927585bca1b19195f721d9a0227d8\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs10
shape(1, 1, 2, 5)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-195ddba553c92b5e66219e1973236728
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 1\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 5\n", + " 2\n", + " 1\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer8: sum-partial

\n", + " \n", + "

\n", + " sum-partial-98b12ff3cd3453d75368bf0e9791036d\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs3
shape(1, 1, 1, 3)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-949927585bca1b19195f721d9a0227d8
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 1\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 3\n", + " 1\n", + " 1\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer9: sum-partial

\n", + " \n", + "

\n", + " sum-partial-587bc2f53cbefe8f07dc91d9af74b9b6\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs2
shape(1, 1, 1, 2)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-98b12ff3cd3453d75368bf0e9791036d
\n", + " 		\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 1\n", + " 1\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 2\n", + " 1\n", + " 1\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer10: sum-aggregate

\n", + " \n", + "

\n", + " sum-aggregate-bd22d0cf0cc5341d41d6ae33afbbbb2b\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-587bc2f53cbefe8f07dc91d9af74b9b6
\n", + " 		\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "
\n", + " \n", + "

Layer11: truediv

\n", + " \n", + "

\n", + " truediv-86f16d005df2161dfe2a1ab1fc01af33\n", + "

\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_typeBlockwise
is_materializedFalse
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-aggregate-bd22d0cf0cc5341d41d6ae33afbbbb2b
\n", + " 		\n", + " \n", + "
\n", + "\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + "
" + ], + "text/plain": [ + "HighLevelGraph with 11 layers.\n", + "\n", + " 0. random_sample-fd9ba15cb13072de19fd66472e82d66b\n", + " 1. random_sample-d33fff662d9857f9295d0807ee4a599e\n", + " 2. sub-4ba45aefc017b35e78ba2b9912547e10\n", + " 3. pow-f301b90316782c72884ebae330cbf967\n", + " 4. sum-28891e8622913ca84905020d6916a344\n", + " 5. sum-partial-195ddba553c92b5e66219e1973236728\n", + " 6. sum-partial-949927585bca1b19195f721d9a0227d8\n", + " 7. sum-partial-98b12ff3cd3453d75368bf0e9791036d\n", + " 8. sum-partial-587bc2f53cbefe8f07dc91d9af74b9b6\n", + " 9. sum-aggregate-bd22d0cf0cc5341d41d6ae33afbbbb2b\n", + " 10. truediv-86f16d005df2161dfe2a1ab1fc01af33" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "mse_graph.dask" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "id": "a86b1e64-3140-44f4-ade1-cd636216640e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 446 ms, sys: 21.8 ms, total: 468 ms\n", + "Wall time: 3.12 s\n" + ] + }, + { + "data": { + "text/plain": [ + "0.1666746512370409" + ] + }, + "execution_count": 50, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "%%time\n", "mse_graph.compute()" ] }, + { + "cell_type": "code", + "execution_count": 51, + "id": "be018325-ef95-424a-9bf2-24d33a26c640", + "metadata": {}, + "outputs": [], + "source": [ + "client.shutdown()" + ] + }, { "cell_type": "markdown", "id": "024686ad-6bfa-48ba-bd85-d005f9477902", From 2f38ee69718cc2f073a82cc5bbf29283427aff20 Mon Sep 17 00:00:00 2001 From: Brian Vanderwende Date: Mon, 6 Feb 2023 11:58:41 -0700 Subject: [PATCH 2/2] Clean HPC notebooks --- notebooks/05-dask-hpc.ipynb | 1325 +---- notebooks/06-dask-chunking.ipynb | 8089 +----------------------------- 2 files changed, 143 insertions(+), 9271 deletions(-) diff --git a/notebooks/05-dask-hpc.ipynb b/notebooks/05-dask-hpc.ipynb index 2ad1732..f39ff25 100644 --- a/notebooks/05-dask-hpc.ipynb +++ b/notebooks/05-dask-hpc.ipynb @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "d317a0ce-f1b8-47c5-8790-a9fd266ca248", "metadata": {}, "outputs": [], @@ -90,21 +90,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "4b0ecda0-2777-4fcd-a1a8-f3cd462f4fe6", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/node.py:183: UserWarning: Port 8787 is already in use.\n", - "Perhaps you already have a cluster running?\n", - "Hosting the HTTP server on port 39174 instead\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "# Create a PBS cluster object\n", "cluster = PBSCluster(\n", @@ -157,30 +146,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "10475615-7181-4b46-b807-7e210d488c73", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#!/usr/bin/env bash\n", - "\n", - "#PBS -N dask-wk23-hpc\n", - "#PBS -q casper\n", - "#PBS -A SCSG0001\n", - "#PBS -l select=1:ncpus=1:mem=4GB\n", - "#PBS -l walltime=30:00\n", - "#PBS -e dask-worker-logs/\n", - "#PBS -o dask-worker-logs/\n", - "#PBS -j oe\n", - "\n", - "/glade/u/apps/opt/conda/envs/npl-2023a/bin/python -m distributed.cli.dask_worker tcp://10.12.206.46:36425 --nthreads 1 --memory-limit 4.00GiB --name dummy-name --nanny --death-timeout 60 --local-directory /local_scratch/pbs.$PBS_JOBID/dask/spill --interface ib0\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "print(cluster.job_script())" ] @@ -218,60 +187,20 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "8a955a20-eeac-4ea9-8220-e7951fe18e05", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "distributed.yaml jobqueue.yaml labextension.yaml\n" - ] - } - ], + "outputs": [], "source": [ "!ls ~/.config/dask" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "7599a5e1-ffab-4a8f-9998-92e7dfc933ef", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'name': 'dask-worker',\n", - " 'cores': 1,\n", - " 'memory': '2GiB',\n", - " 'processes': 1,\n", - " 'interface': 'ib0',\n", - " 'death-timeout': 60,\n", - " 'local-directory': '/local_scratch/pbs.$PBS_JOBID/dask',\n", - " 'shared-temp-directory': None,\n", - " 'extra': None,\n", - " 'worker-extra-args': [],\n", - " 'shebang': '#!/usr/bin/env bash',\n", - " 'queue': 'casper',\n", - " 'account': 'SCSG0001',\n", - " 'walltime': '00:30:00',\n", - " 'env-extra': None,\n", - " 'job-script-prologue': [],\n", - " 'resource-spec': '-l select=1:ncpus=1:mem=2GB',\n", - " 'job-extra': None,\n", - " 'job-extra-directives': ['-j oe'],\n", - " 'job-directives-skip': [],\n", - " 'log-directory': 'dask-worker-logs',\n", - " 'scheduler-options': {}}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Programmatically view configuration file(s) within Python\n", "from dask import config\n", @@ -295,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "d394abe8-d31b-454d-b3eb-dbf8ae16ddaa", "metadata": {}, "outputs": [], @@ -306,135 +235,10 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "44a153c2-129c-49fd-ba77-7d13fa5048c1", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "
\n", - "
\n", - "

Client

\n", - "

Client-c04bc201-a644-11ed-998a-3cecef1acb68

\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
Connection method: Cluster objectCluster type: dask_jobqueue.PBSCluster
\n", - " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/39174/status\n", - "
\n", - "\n", - " \n", - "
\n", - "

Cluster Info

\n", - "
\n", - "
\n", - "
\n", - "
\n", - "

PBSCluster

\n", - "

ae77153c

\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/39174/status\n", - " \n", - " Workers: 0\n", - "
\n", - " Total threads: 0\n", - " \n", - " Total memory: 0 B\n", - "
\n", - "\n", - "
\n", - " \n", - "

Scheduler Info

\n", - " \n", - "\n", - "
\n", - "
\n", - "
\n", - "
\n", - "

Scheduler

\n", - "

Scheduler-c391f848-0c4a-4fdc-a1f6-e276dc799f1d

\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " Comm: tcp://10.12.206.46:36425\n", - " \n", - " Workers: 0\n", - "
\n", - " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/39174/status\n", - " \n", - " Total threads: 0\n", - "
\n", - " Started: 12 minutes ago\n", - " \n", - " Total memory: 0 B\n", - "
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "

Workers

\n", - " \n", - "\n", - " \n", - "\n", - "
\n", - "
\n", - "\n", - "
\n", - "
\n", - "
\n", - "
\n", - " \n", - "\n", - "
\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Display the client repr\n", "client" @@ -450,7 +254,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "bc7cc604-dfe2-4d7e-b305-3d71ee64428e", "metadata": {}, "outputs": [], @@ -464,22 +268,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "0a45c3b5-aad4-45b1-978b-a2374e83f260", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'PBSCluster-1': ,\n", - " 'PBSCluster-0': }" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# See the workers from the cluster object\n", "cluster.workers" @@ -487,25 +279,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "ad5a6709-858a-4434-9403-56ffe7a04f2e", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Req'd Req'd Elap\n", - "Job ID Username Queue Jobname SessID NDS TSK Memory Time S Time\n", - "--------------- -------- -------- ---------- ------ --- --- ------ ----- - -----\n", - "5525918.casper* vanderwb jhublog* cr-login-* 2269 1 1 4gb 720:0 R 68:43\n", - "5549560.casper* vanderwb htc dask-wk23* 83947 1 1 4gb 00:30 R 00:00\n", - "5549561.casper* vanderwb htc dask-wk23* 84096 1 1 4gb 00:30 R 00:00\n", - "\n", - "Cached at: Mon Feb 6 10:40:04 MST 2023\n" - ] - } - ], + "outputs": [], "source": [ "# See the workers in the job scheduler\n", "!qstat -u $USER" @@ -531,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "a62fe240-c8bc-4857-9e03-7af100baa2cb", "metadata": {}, "outputs": [], @@ -541,7 +318,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "6d8edc52-70ad-4a20-ad41-3596838f621b", "metadata": {}, "outputs": [], @@ -552,18 +329,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "dcf1b6f7-3290-4ffb-a982-c5e209e482b0", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Size of Variable = 33.86 GiB\n" - ] - } - ], + "outputs": [], "source": [ "# Show the total size of the variable (this has not been read in yet!)\n", "print(\"Size of Variable = {:5.2f} GiB\".format(ds.T.nbytes / 1024 ** 3))" @@ -579,666 +348,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "77a4042b-a3a2-4731-9ebb-33011337fecb", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'T' (time: 152, lev: 72, lat: 721, lon: 1152)>\n",
-       "dask.array<concatenate, shape=(152, 72, 721, 1152), dtype=float32, chunksize=(8, 72, 721, 1152), chunktype=numpy.ndarray>\n",
-       "Coordinates:\n",
-       "  * lon      (lon) float64 0.0 0.3125 0.625 0.9375 ... 358.8 359.1 359.4 359.7\n",
-       "  * lat      (lat) float64 -90.0 -89.75 -89.5 -89.25 ... 89.25 89.5 89.75 90.0\n",
-       "  * time     (time) datetime64[ns] 2022-01-01 ... 2022-01-19T21:00:00\n",
-       "  * lev      (lev) float32 0.015 0.02635 0.04014 0.05679 ... 962.5 977.5 992.5\n",
-       "Attributes:\n",
-       "    long_name:       air_temperature\n",
-       "    units:           K\n",
-       "    fmissing_value:  1000000000000000.0\n",
-       "    standard_name:   air_temperature\n",
-       "    vmax:            1000000000000000.0\n",
-       "    vmin:            -1000000000000000.0\n",
-       "    valid_range:     [-1.e+15  1.e+15]
" - ], - "text/plain": [ - "\n", - "dask.array\n", - "Coordinates:\n", - " * lon (lon) float64 0.0 0.3125 0.625 0.9375 ... 358.8 359.1 359.4 359.7\n", - " * lat (lat) float64 -90.0 -89.75 -89.5 -89.25 ... 89.25 89.5 89.75 90.0\n", - " * time (time) datetime64[ns] 2022-01-01 ... 2022-01-19T21:00:00\n", - " * lev (lev) float32 0.015 0.02635 0.04014 0.05679 ... 962.5 977.5 992.5\n", - "Attributes:\n", - " long_name: air_temperature\n", - " units: K\n", - " fmissing_value: 1000000000000000.0\n", - " standard_name: air_temperature\n", - " vmax: 1000000000000000.0\n", - " vmin: -1000000000000000.0\n", - " valid_range: [-1.e+15 1.e+15]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# The graphical repr of one DaskArray - T\n", "ds.T" @@ -1259,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "0d37e389-3f74-4798-ae85-0a94f9b5c19f", "metadata": {}, "outputs": [], @@ -1270,22 +383,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "ee71e697-92c0-4832-9395-0864f3c7fac7", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Tip - double-click the figure to see the actual size\n", "dask.visualize(sfc_mean_graph)" @@ -1301,19 +402,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "4b746a91-75cc-4173-9cc1-9a6d1afd6c38", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 1.3 s, sys: 131 ms, total: 1.43 s\n", - "Wall time: 34.8 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = sfc_mean_graph.compute()" @@ -1321,31 +413,10 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "ab77998c-2fd0-4672-be8c-8fedd11660a4", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "result.plot()" ] @@ -1360,7 +431,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "6c28c82e-e191-42ca-85ba-4a911a4ca50c", "metadata": {}, "outputs": [], @@ -1372,27 +443,10 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "0221d503-9bcd-4cd7-9999-8449bcf556b4", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Req'd Req'd Elap\n", - "Job ID Username Queue Jobname SessID NDS TSK Memory Time S Time\n", - "--------------- -------- -------- ---------- ------ --- --- ------ ----- - -----\n", - "5525918.casper* vanderwb jhublog* cr-login-* 2269 1 1 4gb 720:0 R 68:51\n", - "5549560.casper* vanderwb htc dask-wk23* 83947 1 1 4gb 00:30 R 00:08\n", - "5549561.casper* vanderwb htc dask-wk23* 84096 1 1 4gb 00:30 R 00:08\n", - "5549594.casper* vanderwb htc dask-wk23* 97096 1 1 4gb 00:30 R 00:00\n", - "5549595.casper* vanderwb htc dask-wk23* 84490 1 1 4gb 00:30 R 00:00\n", - "\n", - "Cached at: Mon Feb 6 10:48:44 MST 2023\n" - ] - } - ], + "outputs": [], "source": [ "# How does this look in PBS?\n", "!qstat -u vanderwb" @@ -1410,7 +464,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "id": "36abd4e9-4294-4eb9-a5e4-2f3d85a2f7c6", "metadata": {}, "outputs": [], @@ -1421,19 +475,10 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "2e4d4d5a-a3f8-4f8d-a3af-fd033c51f337", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 1.02 s, sys: 69.2 ms, total: 1.09 s\n", - "Wall time: 17.9 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "# Since metrics are captured live anyway, the overhead from the report is small\n", @@ -1453,7 +498,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "c9a900c8-be09-4039-a95a-2617bcd463c3", "metadata": {}, "outputs": [], @@ -1464,19 +509,10 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "id": "22bf9403-0186-46bd-8cd5-c0d613be6162", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 248 ms, sys: 9.44 ms, total: 258 ms\n", - "Wall time: 5.45 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = sfc_mean_graph.compute()" @@ -1497,7 +533,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "id": "0a2fd78d-e116-4e5b-95ad-a75e5e24b6d3", "metadata": {}, "outputs": [], @@ -1508,19 +544,10 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "id": "7224a727-6873-4988-afcf-b4bf40182015", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 200 ms, sys: 14.8 ms, total: 215 ms\n", - "Wall time: 4.84 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = sfc_mean_graph.compute()" @@ -1538,31 +565,10 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": null, "id": "3d727024-d802-46b0-8138-a08e6f118433", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "result.plot()" ] @@ -1601,7 +607,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "767453d0-148b-4281-b767-5831569868f2", "metadata": {}, "outputs": [], @@ -1612,19 +618,10 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "id": "228524e0-3ffa-4740-a4a1-eaf9fc101c2c", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 937 ms, sys: 81 ms, total: 1.02 s\n", - "Wall time: 25 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "# Without persistance\n", @@ -1636,19 +633,10 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "id": "39882b19-e745-4b44-a2c4-d19ffa662aa1", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 596 ms, sys: 44 ms, total: 640 ms\n", - "Wall time: 15.9 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "# With persistance\n", @@ -1671,31 +659,10 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "id": "4966cc57-42f6-4f81-9386-dc5c5dbe3043", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ms.plot(align=True)" ] @@ -1712,7 +679,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "id": "47eb05e6-f35e-473b-bed8-55e625d8b6f7", "metadata": {}, "outputs": [], @@ -1722,7 +689,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "id": "aa1b4fb0-ed7e-48be-a8f4-550e5edbc415", "metadata": {}, "outputs": [], @@ -1762,7 +729,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "id": "1c2a719a-6e10-4aa5-a267-9a320616643a", "metadata": {}, "outputs": [], @@ -1783,7 +750,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "id": "55a817f6-6a9e-440d-b118-39ff99385cb6", "metadata": {}, "outputs": [], @@ -1794,7 +761,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "id": "a2eb9129-8105-4954-b00c-69c822f92bfc", "metadata": {}, "outputs": [], @@ -1806,40 +773,10 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "id": "46f1ea0c-63a1-4e6a-9c20-819592047235", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Mean of 1600 MiB random array = 0.50\n", - "Mean of 2400 MiB random array = 0.50\n", - "Mean of 3200 MiB random array = 0.50\n" - ] - }, - { - "ename": "KilledWorker", - "evalue": "Attempted to run task ('random_sample-mean_chunk-fa2b790a89674d7f8b087dd85b1f120d', 0) on 3 different workers, but all those workers died while running it. The last worker that attempt to run the task was tcp://10.12.206.32:39212. Inspecting worker logs is often a good next step to diagnose what went wrong. For more information see https://distributed.dask.org/en/stable/killed.html.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKilledWorker\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[37], line 4\u001b[0m\n\u001b[1;32m 2\u001b[0m client\u001b[38;5;241m.\u001b[39mrun(log_message, chunk_mib)\n\u001b[1;32m 3\u001b[0m chunk_size \u001b[38;5;241m=\u001b[39m chunk_mib \u001b[38;5;241m/\u001b[39m \u001b[38;5;241m8\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m1024\u001b[39m \u001b[38;5;241m*\u001b[39m \u001b[38;5;241m1024\u001b[39m\n\u001b[0;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mMean of \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m MiB random array = \u001b[39m\u001b[38;5;132;01m{:0.2f}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(chunk_mib, \u001b[43mda\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrandom\u001b[49m\u001b[43m(\u001b[49m\u001b[43m(\u001b[49m\u001b[43mchunk_size\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchunks\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mchunk_size\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmean\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcompute\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m))\n", - "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/dask/base.py:315\u001b[0m, in \u001b[0;36mDaskMethodsMixin.compute\u001b[0;34m(self, **kwargs)\u001b[0m\n\u001b[1;32m 291\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mcompute\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m 292\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Compute this dask collection\u001b[39;00m\n\u001b[1;32m 293\u001b[0m \n\u001b[1;32m 294\u001b[0m \u001b[38;5;124;03m This turns a lazy Dask collection into its in-memory equivalent.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 313\u001b[0m \u001b[38;5;124;03m dask.base.compute\u001b[39;00m\n\u001b[1;32m 314\u001b[0m \u001b[38;5;124;03m \"\"\"\u001b[39;00m\n\u001b[0;32m--> 315\u001b[0m (result,) \u001b[38;5;241m=\u001b[39m \u001b[43mcompute\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtraverse\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 316\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/dask/base.py:600\u001b[0m, in \u001b[0;36mcompute\u001b[0;34m(traverse, optimize_graph, scheduler, get, *args, **kwargs)\u001b[0m\n\u001b[1;32m 597\u001b[0m keys\u001b[38;5;241m.\u001b[39mappend(x\u001b[38;5;241m.\u001b[39m__dask_keys__())\n\u001b[1;32m 598\u001b[0m postcomputes\u001b[38;5;241m.\u001b[39mappend(x\u001b[38;5;241m.\u001b[39m__dask_postcompute__())\n\u001b[0;32m--> 600\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[43mschedule\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdsk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeys\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 601\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m repack([f(r, \u001b[38;5;241m*\u001b[39ma) \u001b[38;5;28;01mfor\u001b[39;00m r, (f, a) \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(results, postcomputes)])\n", - "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/client.py:3057\u001b[0m, in \u001b[0;36mClient.get\u001b[0;34m(self, dsk, keys, workers, allow_other_workers, resources, sync, asynchronous, direct, retries, priority, fifo_timeout, actors, **kwargs)\u001b[0m\n\u001b[1;32m 3055\u001b[0m should_rejoin \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[1;32m 3056\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 3057\u001b[0m results \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mgather\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpacked\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43masynchronous\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43masynchronous\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdirect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdirect\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3058\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 3059\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m f \u001b[38;5;129;01min\u001b[39;00m futures\u001b[38;5;241m.\u001b[39mvalues():\n", - "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/client.py:2226\u001b[0m, in \u001b[0;36mClient.gather\u001b[0;34m(self, futures, errors, direct, asynchronous)\u001b[0m\n\u001b[1;32m 2224\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 2225\u001b[0m local_worker \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 2226\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msync\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 2227\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_gather\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2228\u001b[0m \u001b[43m \u001b[49m\u001b[43mfutures\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2229\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2230\u001b[0m \u001b[43m \u001b[49m\u001b[43mdirect\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdirect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2231\u001b[0m \u001b[43m \u001b[49m\u001b[43mlocal_worker\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlocal_worker\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2232\u001b[0m \u001b[43m \u001b[49m\u001b[43masynchronous\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43masynchronous\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 2233\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/utils.py:339\u001b[0m, in \u001b[0;36mSyncMethodMixin.sync\u001b[0;34m(self, func, asynchronous, callback_timeout, *args, **kwargs)\u001b[0m\n\u001b[1;32m 337\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m future\n\u001b[1;32m 338\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 339\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43msync\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 340\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mloop\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcallback_timeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcallback_timeout\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\n\u001b[1;32m 341\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/utils.py:406\u001b[0m, in \u001b[0;36msync\u001b[0;34m(loop, func, callback_timeout, *args, **kwargs)\u001b[0m\n\u001b[1;32m 404\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m error:\n\u001b[1;32m 405\u001b[0m typ, exc, tb \u001b[38;5;241m=\u001b[39m error\n\u001b[0;32m--> 406\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\u001b[38;5;241m.\u001b[39mwith_traceback(tb)\n\u001b[1;32m 407\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 408\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", - "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/utils.py:379\u001b[0m, in \u001b[0;36msync..f\u001b[0;34m()\u001b[0m\n\u001b[1;32m 377\u001b[0m future \u001b[38;5;241m=\u001b[39m asyncio\u001b[38;5;241m.\u001b[39mwait_for(future, callback_timeout)\n\u001b[1;32m 378\u001b[0m future \u001b[38;5;241m=\u001b[39m asyncio\u001b[38;5;241m.\u001b[39mensure_future(future)\n\u001b[0;32m--> 379\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01myield\u001b[39;00m future\n\u001b[1;32m 380\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 381\u001b[0m error \u001b[38;5;241m=\u001b[39m sys\u001b[38;5;241m.\u001b[39mexc_info()\n", - "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/tornado/gen.py:762\u001b[0m, in \u001b[0;36mRunner.run\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 759\u001b[0m exc_info \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 761\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 762\u001b[0m value \u001b[38;5;241m=\u001b[39m \u001b[43mfuture\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mresult\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 763\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m 764\u001b[0m exc_info \u001b[38;5;241m=\u001b[39m sys\u001b[38;5;241m.\u001b[39mexc_info()\n", - "File \u001b[0;32m/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/client.py:2089\u001b[0m, in \u001b[0;36mClient._gather\u001b[0;34m(self, futures, errors, direct, local_worker)\u001b[0m\n\u001b[1;32m 2087\u001b[0m exc \u001b[38;5;241m=\u001b[39m CancelledError(key)\n\u001b[1;32m 2088\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 2089\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exception\u001b[38;5;241m.\u001b[39mwith_traceback(traceback)\n\u001b[1;32m 2090\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\n\u001b[1;32m 2091\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m errors \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mskip\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n", - "\u001b[0;31mKilledWorker\u001b[0m: Attempted to run task ('random_sample-mean_chunk-fa2b790a89674d7f8b087dd85b1f120d', 0) on 3 different workers, but all those workers died while running it. The last worker that attempt to run the task was tcp://10.12.206.32:39212. Inspecting worker logs is often a good next step to diagnose what went wrong. For more information see https://distributed.dask.org/en/stable/killed.html." - ] - } - ], + "outputs": [], "source": [ "for chunk_mib in [1600, 2400, 3200, 3900]:\n", " client.run(log_message, chunk_mib)\n", @@ -1849,21 +786,10 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "id": "456149fc-3fe5-482b-83bb-8d0ab5f11673", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-rw-r--r-- 1 vanderwb csgteam 24446 Feb 6 11:11 5549719.casper-pbs.OU\n", - "-rw-r--r-- 1 vanderwb csgteam 24452 Feb 6 11:11 5549721.casper-pbs.OU\n", - "-rw-r--r-- 1 vanderwb csgteam 24099 Feb 6 11:11 5549720.casper-pbs.OU\n", - "-rw-r--r-- 1 vanderwb csgteam 24446 Feb 6 11:11 5549718.casper-pbs.OU\n" - ] - } - ], + "outputs": [], "source": [ "# List the most recent 4 worker logs - these should be our logs\n", "!ls -lrt dask-worker-logs | tail -n 4" @@ -1879,27 +805,10 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "id": "ee6e1e52-9078-4bf5-8c03-edabbfbb7629", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Req'd Req'd Elap\n", - "Job ID Username Queue Jobname SessID NDS TSK Memory Time S Time\n", - "--------------- -------- -------- ---------- ------ --- --- ------ ----- - -----\n", - "5525918.casper* vanderwb jhublog* cr-login-* 2269 1 1 4gb 720:0 R 69:17\n", - "5549718.casper* vanderwb htc dask-wk23* 94402 1 1 4gb 00:30 R 00:04\n", - "5549719.casper* vanderwb htc dask-wk23* 94285 1 1 4gb 00:30 R 00:04\n", - "5549720.casper* vanderwb htc dask-wk23* 197151 1 1 4gb 00:30 R 00:04\n", - "5549721.casper* vanderwb htc dask-wk23* 197196 1 1 4gb 00:30 R 00:04\n", - "\n", - "Cached at: Mon Feb 6 11:15:35 MST 2023\n" - ] - } - ], + "outputs": [], "source": [ "# Let's look at the worker state in PBS after the failure\n", "!qstat -u vanderwb" @@ -1919,7 +828,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "id": "ec0635f9-8b2c-44b4-86f7-0d35b6765242", "metadata": {}, "outputs": [], @@ -1948,21 +857,10 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "id": "e848ef4b-a28d-472a-98a0-27f75254e8ab", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'dask-wk23-hpc'" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "cluster.job_name" ] @@ -1985,7 +883,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "id": "0e2b5bd8-96d7-4180-b1b7-f491cab24804", "metadata": {}, "outputs": [], @@ -1995,85 +893,10 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "id": "730c5d64-0567-464e-87af-63840f878ed6", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Job IDNCPUsElapsed (h)
05526022.casper-pbs10.05
15526023.casper-pbs10.05
25526025.casper-pbs10.05
35526024.casper-pbs10.05
45525958.casper-pbs10.25
\n", - "
" - ], - "text/plain": [ - " Job ID NCPUs Elapsed (h)\n", - "0 5526022.casper-pbs 1 0.05\n", - "1 5526023.casper-pbs 1 0.05\n", - "2 5526025.casper-pbs 1 0.05\n", - "3 5526024.casper-pbs 1 0.05\n", - "4 5525958.casper-pbs 1 0.25" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "dj = pd.read_csv(\"../data/qhist-dask.out\")\n", "dj.head()" @@ -2081,18 +904,10 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "id": "d766238b-6d3a-4aa3-85c5-71802d86a0d7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Core-hours used by this notebook: 1.12\n" - ] - } - ], + "outputs": [], "source": [ "print(\"Core-hours used by this notebook: {:.2f}\".format(sum(dj['NCPUs'] * dj['Elapsed (h)'])))" ] diff --git a/notebooks/06-dask-chunking.ipynb b/notebooks/06-dask-chunking.ipynb index 23e0bd3..8da6907 100644 --- a/notebooks/06-dask-chunking.ipynb +++ b/notebooks/06-dask-chunking.ipynb @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "d317a0ce-f1b8-47c5-8790-a9fd266ca248", "metadata": {}, "outputs": [], @@ -90,21 +90,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "4b0ecda0-2777-4fcd-a1a8-f3cd462f4fe6", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/glade/u/apps/opt/conda/envs/npl-2023a/lib/python3.9/site-packages/distributed/node.py:183: UserWarning: Port 8787 is already in use.\n", - "Perhaps you already have a cluster running?\n", - "Hosting the HTTP server on port 42815 instead\n", - " warnings.warn(\n" - ] - } - ], + "outputs": [], "source": [ "# Create a PBS cluster object\n", "cluster = PBSCluster(\n", @@ -122,30 +111,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "10475615-7181-4b46-b807-7e210d488c73", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#!/usr/bin/env bash\n", - "\n", - "#PBS -N dask-wk23-chunking\n", - "#PBS -q casper\n", - "#PBS -A SCSG0001\n", - "#PBS -l select=1:ncpus=1:mem=10GB\n", - "#PBS -l walltime=30:00\n", - "#PBS -e dask-worker-logs/\n", - "#PBS -o dask-worker-logs/\n", - "#PBS -j oe\n", - "\n", - "/glade/u/apps/opt/conda/envs/npl-2023a/bin/python -m distributed.cli.dask_worker tcp://10.12.206.46:41979 --nthreads 1 --memory-limit 10.00GiB --name dummy-name --nanny --death-timeout 60 --local-directory /glade/scratch/vanderwb/temp/dask/spill/pbs.$PBS_JOBID --interface ib0\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "# Sanity-check our setup\n", "print(cluster.job_script())" @@ -153,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "107629fa-34a3-426c-828e-bafe6a8d7ca2", "metadata": { "tags": [] @@ -165,135 +134,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "c82f23a4-a8f3-412e-b511-7b2f2c96c552", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "
\n", - "
\n", - "

Client

\n", - "

Client-0c11bd37-a64c-11ed-affc-3cecef1acb68

\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
Connection method: Cluster objectCluster type: dask_jobqueue.PBSCluster
\n", - " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/42815/status\n", - "
\n", - "\n", - " \n", - "
\n", - "

Cluster Info

\n", - "
\n", - "
\n", - "
\n", - "
\n", - "

PBSCluster

\n", - "

d23f7926

\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/42815/status\n", - " \n", - " Workers: 0\n", - "
\n", - " Total threads: 0\n", - " \n", - " Total memory: 0 B\n", - "
\n", - "\n", - "
\n", - " \n", - "

Scheduler Info

\n", - " \n", - "\n", - "
\n", - "
\n", - "
\n", - "
\n", - "

Scheduler

\n", - "

Scheduler-e70f971e-6622-432c-ad59-8515b1fd81f5

\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " Comm: tcp://10.12.206.46:41979\n", - " \n", - " Workers: 0\n", - "
\n", - " Dashboard: https://jupyterhub.hpc.ucar.edu/stable/user/vanderwb/Casper/proxy/42815/status\n", - " \n", - " Total threads: 0\n", - "
\n", - " Started: Just now\n", - " \n", - " Total memory: 0 B\n", - "
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "

Workers

\n", - " \n", - "\n", - " \n", - "\n", - "
\n", - "
\n", - "\n", - "
\n", - "
\n", - "
\n", - "
\n", - " \n", - "\n", - "
\n", - "
" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "client" ] @@ -327,7 +171,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "dbb9aa86-182b-4ca6-bf62-d8a7884b0306", "metadata": {}, "outputs": [], @@ -347,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "7efdf2dc-2d99-43ad-a0a6-a3aa71049e1e", "metadata": {}, "outputs": [], @@ -357,83 +201,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "d9d2aa49-94d0-4cd1-bc28-db3aef3815d5", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Array Chunk
Bytes 32.19 GiB 8.05 GiB
Shape (60000, 72000) (30000, 36000)
Count 1 Graph Layer 4 Chunks
Type float64 numpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 72000\n", - " 60000\n", - "\n", - "
" - ], - "text/plain": [ - "dask.array" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "t = da.random.random((60000, 72000), chunks = (30000,36000))\n", "t" @@ -449,316 +220,10 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "47da0213-4c7e-483e-99a3-73393559c817", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "

HighLevelGraph

\n", - "

\n", - " HighLevelGraph with 3 layers and 9 keys from all layers.\n", - "

\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer1: random_sample

\n", - " \n", - "

\n", - " random_sample-99d384ebf7643e046beb2659e21d477c\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs4
shape(60000, 72000)
dtypefloat64
chunksize(30000, 36000)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 72000\n", - " 60000\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer2: mean_chunk

\n", - " \n", - "

\n", - " mean_chunk-1db7ddb1bae521842cca9af0d431c4c5\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs4
shape(60000, 72000)
dtypefloat64
chunksize(30000, 36000)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-99d384ebf7643e046beb2659e21d477c
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 72000\n", - " 60000\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer3: mean_agg-aggregate

\n", - " \n", - "

\n", - " mean_agg-aggregate-b00133a3cd939d8bebad9aae1408daf7\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_chunk-1db7ddb1bae521842cca9af0d431c4c5
\n", - " 		\n", - " \n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - "
\n", - "
" - ], - "text/plain": [ - "HighLevelGraph with 3 layers.\n", - "\n", - " 0. random_sample-99d384ebf7643e046beb2659e21d477c\n", - " 1. mean_chunk-1db7ddb1bae521842cca9af0d431c4c5\n", - " 2. mean_agg-aggregate-b00133a3cd939d8bebad9aae1408daf7" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "task = t.mean()\n", "task.dask" @@ -766,19 +231,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "d74ce6b4-88d3-495e-8b54-66d69b68a614", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 608 ms, sys: 143 ms, total: 751 ms\n", - "Wall time: 10.4 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = task.compute()" @@ -794,117 +250,10 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "552aa90c-908d-42ca-bcad-bfad2e8022ef", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Array Chunk
Bytes 32.19 GiB 7.63 MiB
Shape (60000, 72000) (1000, 1000)
Count 1 Graph Layer 4320 Chunks
Type float64 numpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 72000\n", - " 60000\n", - "\n", - "
" - ], - "text/plain": [ - "dask.array" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "t = da.random.random((60000, 72000), chunks = (1000,1000))\n", "t" @@ -912,1129 +261,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "57a139e9-ecf6-45d8-a3de-cf7d2561b8a6", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "

HighLevelGraph

\n", - "

\n", - " HighLevelGraph with 9 layers and 10091 keys from all layers.\n", - "

\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer1: random_sample

\n", - " \n", - "

\n", - " random_sample-d864cc98d7b0c810e3981396d0a31505\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs4320
shape(60000, 72000)
dtypefloat64
chunksize(1000, 1000)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 72000\n", - " 60000\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer2: mean_chunk

\n", - " \n", - "

\n", - " mean_chunk-2d6be3ffa6620a03b940271bbcfde966\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs4320
shape(60000, 72000)
dtypefloat64
chunksize(1000, 1000)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-d864cc98d7b0c810e3981396d0a31505
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 72000\n", - " 60000\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer3: mean_combine-partial

\n", - " \n", - "

\n", - " mean_combine-partial-29b2186694d79f2d7731b08940ea330c\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1080
shape(30, 36)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_chunk-2d6be3ffa6620a03b940271bbcfde966
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 36\n", - " 30\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer4: mean_combine-partial

\n", - " \n", - "

\n", - " mean_combine-partial-58ad99c24bbf255733617407d84da342\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs270
shape(15, 18)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-29b2186694d79f2d7731b08940ea330c
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 18\n", - " 15\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer5: mean_combine-partial

\n", - " \n", - "

\n", - " mean_combine-partial-455a2b59687d27f757814666f78b9772\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs72
shape(8, 9)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-58ad99c24bbf255733617407d84da342
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 9\n", - " 8\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer6: mean_combine-partial

\n", - " \n", - "

\n", - " mean_combine-partial-6cd2c59ea14367c391f8098f19de908a\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs20
shape(4, 5)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-455a2b59687d27f757814666f78b9772
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 5\n", - " 4\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer7: mean_combine-partial

\n", - " \n", - "

\n", - " mean_combine-partial-ae112b9d4ead8774877687e1fe1a34f6\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs6
shape(2, 3)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-6cd2c59ea14367c391f8098f19de908a
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 3\n", - " 2\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer8: mean_combine-partial

\n", - " \n", - "

\n", - " mean_combine-partial-0e2db5ea9697d821664c1bb0b1bc891f\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs2
shape(1, 2)
dtypefloat64
chunksize(1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-ae112b9d4ead8774877687e1fe1a34f6
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 2\n", - " 1\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer9: mean_agg-aggregate

\n", - " \n", - "

\n", - " mean_agg-aggregate-2ed8945b01b8b27bf89378b4d820bdf5\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on mean_combine-partial-0e2db5ea9697d821664c1bb0b1bc891f
\n", - " 		\n", - " \n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - "
\n", - "
" - ], - "text/plain": [ - "HighLevelGraph with 9 layers.\n", - "\n", - " 0. random_sample-d864cc98d7b0c810e3981396d0a31505\n", - " 1. mean_chunk-2d6be3ffa6620a03b940271bbcfde966\n", - " 2. mean_combine-partial-29b2186694d79f2d7731b08940ea330c\n", - " 3. mean_combine-partial-58ad99c24bbf255733617407d84da342\n", - " 4. mean_combine-partial-455a2b59687d27f757814666f78b9772\n", - " 5. mean_combine-partial-6cd2c59ea14367c391f8098f19de908a\n", - " 6. mean_combine-partial-ae112b9d4ead8774877687e1fe1a34f6\n", - " 7. mean_combine-partial-0e2db5ea9697d821664c1bb0b1bc891f\n", - " 8. mean_agg-aggregate-2ed8945b01b8b27bf89378b4d820bdf5" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "task = t.mean()\n", "task.dask" @@ -2042,19 +272,10 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "3c72dedb-2ea7-4d8a-8c90-479a9492694c", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 5.78 s, sys: 262 ms, total: 6.04 s\n", - "Wall time: 12.8 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = task.compute()" @@ -2070,97 +291,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "4bbedf51-7548-477d-bdda-b451b7be27c9", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Array Chunk
Bytes 32.19 GiB 457.76 MiB
Shape (60000, 72000) (10000, 6000)
Count 1 Graph Layer 72 Chunks
Type float64 numpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 72000\n", - " 60000\n", - "\n", - "
" - ], - "text/plain": [ - "dask.array" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "t = da.random.random((60000, 72000), chunks = (10000,6000))\n", "t" @@ -2168,19 +302,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "1882a526-d8fd-4406-8bc4-4acc9b666739", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 796 ms, sys: 35.3 ms, total: 831 ms\n", - "Wall time: 9.39 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = t.mean().compute()" @@ -2206,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "d0eedce9-d0df-4235-bcff-6152cfde17da", "metadata": {}, "outputs": [], @@ -2224,7 +349,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "16bdef3e-6c2c-4007-b061-04aa85e052e6", "metadata": {}, "outputs": [], @@ -2242,24 +367,10 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "442f91b0-a174-467c-9095-0bf0e67639fe", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "( (unlimited): name = 'Time', size = 8,\n", - " : name = 'num_metgrid_levels', size = 34,\n", - " : name = 'south_north', size = 720,\n", - " : name = 'west_east', size = 720)" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "nc_data = nc.Dataset(my_file)\n", "nc_data['CLDFRA'].get_dims()" @@ -2275,21 +386,10 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "82965dea-3b73-492a-b013-1f1e363cb9d8", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 16, 355, 355]" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "nc_data['CLDFRA'].chunking()" ] @@ -2306,7 +406,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "d67ca1a2-3102-4f85-b44c-3a001a93e5d5", "metadata": {}, "outputs": [], @@ -2316,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "id": "bf1c6563-00f9-47ed-8e6c-1dcc5f7b0a85", "metadata": {}, "outputs": [], @@ -2342,638 +442,10 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": null, "id": "94a41e94-fafb-4d0e-9988-2569a1f9ef6f", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'CLDFRA' (Time: 8, num_metgrid_levels: 34, south_north: 720,\n",
-       "                            west_east: 720)>\n",
-       "dask.array<open_dataset-2d5c51faf2dc21d9877d4227a4fb805dCLDFRA, shape=(8, 34, 720, 720), dtype=float32, chunksize=(1, 34, 720, 720), chunktype=numpy.ndarray>\n",
-       "Coordinates:\n",
-       "  * Time     (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n",
-       "    XLAT     (south_north, west_east) float32 dask.array<chunksize=(720, 720), meta=np.ndarray>\n",
-       "    XLONG    (south_north, west_east) float32 dask.array<chunksize=(720, 720), meta=np.ndarray>\n",
-       "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n",
-       "Attributes:\n",
-       "    FieldType:    104\n",
-       "    MemoryOrder:  XYZ\n",
-       "    units:        1.0\n",
-       "    stagger:      \n",
-       "    long_name:    CLOUD FRACTION
" - ], - "text/plain": [ - "\n", - "dask.array\n", - "Coordinates:\n", - " * Time (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n", - " XLAT (south_north, west_east) float32 dask.array\n", - " XLONG (south_north, west_east) float32 dask.array\n", - "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n", - "Attributes:\n", - " FieldType: 104\n", - " MemoryOrder: XYZ\n", - " units: 1.0\n", - " stagger: \n", - " long_name: CLOUD FRACTION" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds.CLDFRA" ] @@ -2988,21 +460,10 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "id": "f541f89c-b2f8-49c7-aa93-70ef0bf8df9f", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1, 16, 355, 355)" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds.CLDFRA.encoding[\"chunksizes\"]" ] @@ -3019,19 +480,10 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "id": "48125db1-00ac-4600-a786-7e6e6cb098b7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 163 ms, sys: 28.7 ms, total: 192 ms\n", - "Wall time: 1.73 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -3047,650 +499,10 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "id": "e975b1ff-6c30-4270-ae2b-b945d96c02a0", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'CLDFRA' (Time: 8, num_metgrid_levels: 34, south_north: 720,\n",
-       "                            west_east: 720)>\n",
-       "dask.array<open_dataset-a2a8daca35d216b566b6c638540eeed3CLDFRA, shape=(8, 34, 720, 720), dtype=float32, chunksize=(1, 16, 355, 720), chunktype=numpy.ndarray>\n",
-       "Coordinates:\n",
-       "  * Time     (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n",
-       "    XLAT     (south_north, west_east) float32 dask.array<chunksize=(355, 720), meta=np.ndarray>\n",
-       "    XLONG    (south_north, west_east) float32 dask.array<chunksize=(355, 720), meta=np.ndarray>\n",
-       "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n",
-       "Attributes:\n",
-       "    FieldType:    104\n",
-       "    MemoryOrder:  XYZ\n",
-       "    units:        1.0\n",
-       "    stagger:      \n",
-       "    long_name:    CLOUD FRACTION
" - ], - "text/plain": [ - "\n", - "dask.array\n", - "Coordinates:\n", - " * Time (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n", - " XLAT (south_north, west_east) float32 dask.array\n", - " XLONG (south_north, west_east) float32 dask.array\n", - "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n", - "Attributes:\n", - " FieldType: 104\n", - " MemoryOrder: XYZ\n", - " units: 1.0\n", - " stagger: \n", - " long_name: CLOUD FRACTION" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds = xr.open_dataset(my_file, chunks = {'Time' : 1, \"num_metgrid_levels\" : 16,\n", " \"south_north\" : 355, \"east_west\" : 355})\n", @@ -3699,19 +511,10 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "id": "b9257791-d82e-4564-bfe4-909e9253af3e", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 171 ms, sys: 34.8 ms, total: 206 ms\n", - "Wall time: 1.25 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -3727,7 +530,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "id": "3ab203f6-20a9-4183-b95c-2e119b40f217", "metadata": {}, "outputs": [], @@ -3738,19 +541,10 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "id": "3af94486-17c3-43a8-8bbf-e82cd99cd8c0", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 202 ms, sys: 30.5 ms, total: 233 ms\n", - "Wall time: 2.44 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -3758,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "id": "ea3d0289-a14d-490d-a05e-5b43b3e80091", "metadata": {}, "outputs": [], @@ -3769,19 +563,10 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "id": "01f33087-5468-48a0-a3c0-9dfbced66f49", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 290 ms, sys: 40.4 ms, total: 330 ms\n", - "Wall time: 4.09 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -3797,7 +582,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "id": "82a204b9-95db-4516-a16e-56f30f3d98a6", "metadata": {}, "outputs": [], @@ -3808,657 +593,20 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "id": "0857d634-18cc-4f1f-98fe-b18007dd9394", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.DataArray 'CLDFRA' (Time: 8, num_metgrid_levels: 34, south_north: 720,\n",
-       "                            west_east: 720)>\n",
-       "dask.array<open_dataset-2475367054d27aaab126f113eb08b50aCLDFRA, shape=(8, 34, 720, 720), dtype=float32, chunksize=(5, 23, 539, 539), chunktype=numpy.ndarray>\n",
-       "Coordinates:\n",
-       "  * Time     (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n",
-       "    XLAT     (south_north, west_east) float32 dask.array<chunksize=(720, 720), meta=np.ndarray>\n",
-       "    XLONG    (south_north, west_east) float32 dask.array<chunksize=(720, 720), meta=np.ndarray>\n",
-       "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n",
-       "Attributes:\n",
-       "    FieldType:    104\n",
-       "    MemoryOrder:  XYZ\n",
-       "    units:        1.0\n",
-       "    stagger:      \n",
-       "    long_name:    CLOUD FRACTION
" - ], - "text/plain": [ - "\n", - "dask.array\n", - "Coordinates:\n", - " * Time (Time) datetime64[ns] 2012-09-16 ... 2012-09-16T21:00:00\n", - " XLAT (south_north, west_east) float32 dask.array\n", - " XLONG (south_north, west_east) float32 dask.array\n", - "Dimensions without coordinates: num_metgrid_levels, south_north, west_east\n", - "Attributes:\n", - " FieldType: 104\n", - " MemoryOrder: XYZ\n", - " units: 1.0\n", - " stagger: \n", - " long_name: CLOUD FRACTION" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "ds.CLDFRA" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "id": "04ad72d7-9b25-4516-8cbb-9c5068a881cc", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 239 ms, sys: 47.5 ms, total: 287 ms\n", - "Wall time: 2.94 s\n" - ] - } - ], + "outputs": [], "source": [ "%%time\n", "result = ds.CLDFRA.max(dim = \"num_metgrid_levels\").compute()" @@ -4494,7 +642,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "id": "c6f62d6e-2c35-4298-a546-e570a6736f28", "metadata": {}, "outputs": [], @@ -4504,170 +652,17 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "id": "ee642dae-b1c1-4aa2-873c-ab207be5fb5c", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Array Chunk
Bytes 4.29 GiB 27.47 MiB
Shape (800, 600, 60, 20) (400, 300, 30, 1)
Count 1 Graph Layer 160 Chunks
Type float64 numpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
" - ], - "text/plain": [ - "dask.array" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "old_run" ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "id": "682d897a-4158-49ae-8960-7eac3b67c685", "metadata": {}, "outputs": [], @@ -4677,168 +672,10 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "id": "2e045450-a2a8-49b3-9ada-e9af425ebae2", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Array Chunk
Bytes 4.29 GiB 36.62 MiB
Shape (800, 600, 60, 20) (800, 600, 10, 1)
Count 1 Graph Layer 120 Chunks
Type float64 numpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
" - ], - "text/plain": [ - "dask.array" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "new_run" ] @@ -4853,7 +690,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": null, "id": "7f773a71-37db-4023-ac13-81e7d19dba5e", "metadata": {}, "outputs": [], @@ -4864,2069 +701,10 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "id": "b005b366-dc3b-431b-b381-7dc26c79fee6", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "

HighLevelGraph

\n", - "

\n", - " HighLevelGraph with 13 layers and 3687 keys from all layers.\n", - "

\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer1: random_sample

\n", - " \n", - "

\n", - " random_sample-fd9ba15cb13072de19fd66472e82d66b\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer2: rechunk-merge

\n", - " \n", - "

\n", - " rechunk-merge-9a66792bcfd5f5b508140f8ea4b26a3f\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs960
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-fd9ba15cb13072de19fd66472e82d66b
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer3: random_sample

\n", - " \n", - "

\n", - " random_sample-535b0047aedf555ae5ae35ecd2323a7e\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs160
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 30, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer4: rechunk-merge

\n", - " \n", - "

\n", - " rechunk-merge-9802ca0e00bd1f84b6fc89883f52f318\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs960
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-535b0047aedf555ae5ae35ecd2323a7e
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer5: sub

\n", - " \n", - "

\n", - " sub-d87b5b362e8c84d54f59b448e01dd77b\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs480
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on rechunk-merge-9a66792bcfd5f5b508140f8ea4b26a3f
rechunk-merge-9802ca0e00bd1f84b6fc89883f52f318
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer6: pow

\n", - " \n", - "

\n", - " pow-ab7ec7709815938f98b9bf2bdce1836a\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs480
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sub-d87b5b362e8c84d54f59b448e01dd77b
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer7: sum

\n", - " \n", - "

\n", - " sum-a53d3bfee6626a55a4eda85b50dfe049\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs480
shape(800, 600, 60, 20)
dtypefloat64
chunksize(400, 300, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on pow-ab7ec7709815938f98b9bf2bdce1836a
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer8: sum-partial

\n", - " \n", - "

\n", - " sum-partial-b3ab311847964dd7cac6fb2f34b5db40\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs30
shape(1, 1, 3, 10)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-a53d3bfee6626a55a4eda85b50dfe049
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 1\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 10\n", - " 3\n", - " 1\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer9: sum-partial

\n", - " \n", - "

\n", - " sum-partial-829816d4fdb725fc7f1c3608e4686ee8\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs10
shape(1, 1, 2, 5)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-b3ab311847964dd7cac6fb2f34b5db40
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 1\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 5\n", - " 2\n", - " 1\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer10: sum-partial

\n", - " \n", - "

\n", - " sum-partial-3ff45aea451de0539764b9222b4052ba\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs3
shape(1, 1, 1, 3)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-829816d4fdb725fc7f1c3608e4686ee8
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 1\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 3\n", - " 1\n", - " 1\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer11: sum-partial

\n", - " \n", - "

\n", - " sum-partial-01f450840da28991af2a3b2f763a53e8\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs2
shape(1, 1, 1, 2)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-3ff45aea451de0539764b9222b4052ba
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 1\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 2\n", - " 1\n", - " 1\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer12: sum-aggregate

\n", - " \n", - "

\n", - " sum-aggregate-4af89c3f0415d5889957431839e67b35\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-01f450840da28991af2a3b2f763a53e8
\n", - " 		\n", - " \n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer13: truediv

\n", - " \n", - "

\n", - " truediv-566720733aec6deed737e048a7eceb43\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-aggregate-4af89c3f0415d5889957431839e67b35
\n", - " 		\n", - " \n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - "
\n", - "
" - ], - "text/plain": [ - "HighLevelGraph with 13 layers.\n", - "\n", - " 0. random_sample-fd9ba15cb13072de19fd66472e82d66b\n", - " 1. rechunk-merge-9a66792bcfd5f5b508140f8ea4b26a3f\n", - " 2. random_sample-535b0047aedf555ae5ae35ecd2323a7e\n", - " 3. rechunk-merge-9802ca0e00bd1f84b6fc89883f52f318\n", - " 4. sub-d87b5b362e8c84d54f59b448e01dd77b\n", - " 5. pow-ab7ec7709815938f98b9bf2bdce1836a\n", - " 6. sum-a53d3bfee6626a55a4eda85b50dfe049\n", - " 7. sum-partial-b3ab311847964dd7cac6fb2f34b5db40\n", - " 8. sum-partial-829816d4fdb725fc7f1c3608e4686ee8\n", - " 9. sum-partial-3ff45aea451de0539764b9222b4052ba\n", - " 10. sum-partial-01f450840da28991af2a3b2f763a53e8\n", - " 11. sum-aggregate-4af89c3f0415d5889957431839e67b35\n", - " 12. truediv-566720733aec6deed737e048a7eceb43" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "mse_graph.dask" ] @@ -6941,29 +719,10 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": null, "id": "71844b87-19f7-4b9a-8ae3-54c8fafbea8d", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 2.09 s, sys: 81.1 ms, total: 2.17 s\n", - "Wall time: 6.03 s\n" - ] - }, - { - "data": { - "text/plain": [ - "0.16667671401503523" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "%%time\n", "mse_graph.compute()" @@ -6987,7 +746,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": null, "id": "868a4114-6c60-4078-b6ea-45345702805d", "metadata": {}, "outputs": [], @@ -6997,7 +756,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": null, "id": "3dc6ff9e-0199-4bdf-90f9-90e3de1ea516", "metadata": {}, "outputs": [], @@ -7008,1722 +767,20 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, "id": "fc2cbe54-fa8b-4850-893d-be2874adf7ae", "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "

HighLevelGraph

\n", - "

\n", - " HighLevelGraph with 11 layers and 647 keys from all layers.\n", - "

\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer1: random_sample

\n", - " \n", - "

\n", - " random_sample-fd9ba15cb13072de19fd66472e82d66b\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer2: random_sample

\n", - " \n", - "

\n", - " random_sample-d33fff662d9857f9295d0807ee4a599e\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer3: sub

\n", - " \n", - "

\n", - " sub-4ba45aefc017b35e78ba2b9912547e10\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on random_sample-fd9ba15cb13072de19fd66472e82d66b
random_sample-d33fff662d9857f9295d0807ee4a599e
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer4: pow

\n", - " \n", - "

\n", - " pow-f301b90316782c72884ebae330cbf967\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sub-4ba45aefc017b35e78ba2b9912547e10
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer5: sum

\n", - " \n", - "

\n", - " sum-28891e8622913ca84905020d6916a344\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs120
shape(800, 600, 60, 20)
dtypefloat64
chunksize(800, 600, 10, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on pow-f301b90316782c72884ebae330cbf967
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 800\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 20\n", - " 60\n", - " 600\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer6: sum-partial

\n", - " \n", - "

\n", - " sum-partial-195ddba553c92b5e66219e1973236728\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs30
shape(1, 1, 3, 10)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-28891e8622913ca84905020d6916a344
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 1\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 10\n", - " 3\n", - " 1\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer7: sum-partial

\n", - " \n", - "

\n", - " sum-partial-949927585bca1b19195f721d9a0227d8\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs10
shape(1, 1, 2, 5)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-195ddba553c92b5e66219e1973236728
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 1\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 5\n", - " 2\n", - " 1\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer8: sum-partial

\n", - " \n", - "

\n", - " sum-partial-98b12ff3cd3453d75368bf0e9791036d\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs3
shape(1, 1, 1, 3)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-949927585bca1b19195f721d9a0227d8
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 1\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 3\n", - " 1\n", - " 1\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer9: sum-partial

\n", - " \n", - "

\n", - " sum-partial-587bc2f53cbefe8f07dc91d9af74b9b6\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs2
shape(1, 1, 1, 2)
dtypefloat64
chunksize(1, 1, 1, 1)
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-98b12ff3cd3453d75368bf0e9791036d
\n", - " 		\n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 1\n", - " 1\n", - "\n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - " \n", - " \n", - "\n", - " \n", - " \n", - "\n", - " \n", - " 2\n", - " 1\n", - " 1\n", - "\n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer10: sum-aggregate

\n", - " \n", - "

\n", - " sum-aggregate-bd22d0cf0cc5341d41d6ae33afbbbb2b\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeMaterializedLayer
is_materializedTrue
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-partial-587bc2f53cbefe8f07dc91d9af74b9b6
\n", - " 		\n", - " \n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "\n", - "
\n", - " \n", - "

Layer11: truediv

\n", - " \n", - "

\n", - " truediv-86f16d005df2161dfe2a1ab1fc01af33\n", - "

\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_typeBlockwise
is_materializedFalse
number of outputs1
shape()
dtypefloat64
chunksize()
typedask.array.core.Array
chunk_typenumpy.ndarray
depends on sum-aggregate-bd22d0cf0cc5341d41d6ae33afbbbb2b
\n", - " 		\n", - " \n", - "
\n", - "\n", - "
\n", - "
\n", - " \n", - "
\n", - "
\n", - "
" - ], - "text/plain": [ - "HighLevelGraph with 11 layers.\n", - "\n", - " 0. random_sample-fd9ba15cb13072de19fd66472e82d66b\n", - " 1. random_sample-d33fff662d9857f9295d0807ee4a599e\n", - " 2. sub-4ba45aefc017b35e78ba2b9912547e10\n", - " 3. pow-f301b90316782c72884ebae330cbf967\n", - " 4. sum-28891e8622913ca84905020d6916a344\n", - " 5. sum-partial-195ddba553c92b5e66219e1973236728\n", - " 6. sum-partial-949927585bca1b19195f721d9a0227d8\n", - " 7. sum-partial-98b12ff3cd3453d75368bf0e9791036d\n", - " 8. sum-partial-587bc2f53cbefe8f07dc91d9af74b9b6\n", - " 9. sum-aggregate-bd22d0cf0cc5341d41d6ae33afbbbb2b\n", - " 10. truediv-86f16d005df2161dfe2a1ab1fc01af33" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "mse_graph.dask" ] }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "id": "a86b1e64-3140-44f4-ade1-cd636216640e", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 446 ms, sys: 21.8 ms, total: 468 ms\n", - "Wall time: 3.12 s\n" - ] - }, - { - "data": { - "text/plain": [ - "0.1666746512370409" - ] - }, - "execution_count": 50, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "%%time\n", "mse_graph.compute()" @@ -8731,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": null, "id": "be018325-ef95-424a-9bf2-24d33a26c640", "metadata": {}, "outputs": [],