{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Dask DataFrames\n", "\n", "\"Dask\n", " \n", "Dask Dataframes coordinate many Pandas dataframes, partitioned along an index. They support a large subset of the Pandas API." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Start Dask Client for Dashboard\n", "\n", "Starting the Dask Client is optional. It will provide a dashboard which \n", "is useful to gain insight on the computation. \n", "\n", "The link to the dashboard will become visible when you create the client below. We recommend having it open on one side of your screen while using your notebook on the other side. This can take some effort to arrange your windows, but seeing them both at the same is very useful when learning." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:45.397038Z", "iopub.status.busy": "2021-10-14T16:43:45.396209Z", "iopub.status.idle": "2021-10-14T16:43:47.691150Z", "shell.execute_reply": "2021-10-14T16:43:47.691716Z" } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "
\n", "

Client

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

Cluster

\n", "
    \n", "
  • Workers: 2
    • \n", "
  • Cores: 4
    • \n", "
  • Memory: 2.00 GB
    • \n", "
\n", "
" ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from dask.distributed import Client, progress\n", "client = Client(n_workers=2, threads_per_worker=2, memory_limit='1GB')\n", "client" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Create Random Dataframe\n", "\n", "We create a random timeseries of data with the following attributes:\n", "\n", "1. It stores a record for every 10 seconds of the year 2000\n", "2. It splits that year by month, keeping every month as a separate Pandas dataframe\n", "3. Along with a datetime index it has columns for names, ids, and numeric values\n", "\n", "This is a small dataset of about 240 MB. Increase the number of days or reduce the frequency to practice with a larger dataset." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:47.697283Z", "iopub.status.busy": "2021-10-14T16:43:47.696280Z", "iopub.status.idle": "2021-10-14T16:43:48.002468Z", "shell.execute_reply": "2021-10-14T16:43:48.002954Z" } }, "outputs": [], "source": [ "import dask\n", "import dask.dataframe as dd\n", "df = dask.datasets.timeseries()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unlike Pandas, Dask DataFrames are lazy and so no data is printed here." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:48.014101Z", "iopub.status.busy": "2021-10-14T16:43:48.011337Z", "iopub.status.idle": "2021-10-14T16:43:48.030415Z", "shell.execute_reply": "2021-10-14T16:43:48.030958Z" } }, "outputs": [ { "data": { "text/html": [ "
Dask DataFrame Structure:
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idnamexy
npartitions=30
2000-01-01int64objectfloat64float64
2000-01-02............
...............
2000-01-30............
2000-01-31............
\n", "
\n", "
Dask Name: make-timeseries, 30 tasks
" ], "text/plain": [ "Dask DataFrame Structure:\n", " id name x y\n", "npartitions=30 \n", "2000-01-01 int64 object float64 float64\n", "2000-01-02 ... ... ... ...\n", "... ... ... ... ...\n", "2000-01-30 ... ... ... ...\n", "2000-01-31 ... ... ... ...\n", "Dask Name: make-timeseries, 30 tasks" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But the column names and dtypes are known." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:48.037073Z", "iopub.status.busy": "2021-10-14T16:43:48.036543Z", "iopub.status.idle": "2021-10-14T16:43:48.042351Z", "shell.execute_reply": "2021-10-14T16:43:48.042857Z" } }, "outputs": [ { "data": { "text/plain": [ "id int64\n", "name object\n", "x float64\n", "y float64\n", "dtype: object" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.dtypes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Some operations will automatically display the data." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:48.047543Z", "iopub.status.busy": "2021-10-14T16:43:48.046942Z", "iopub.status.idle": "2021-10-14T16:43:48.050390Z", "shell.execute_reply": "2021-10-14T16:43:48.051314Z" } }, "outputs": [], "source": [ "import pandas as pd\n", "pd.options.display.precision = 2\n", "pd.options.display.max_rows = 10" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:48.058289Z", "iopub.status.busy": "2021-10-14T16:43:48.055670Z", "iopub.status.idle": "2021-10-14T16:43:48.742710Z", "shell.execute_reply": "2021-10-14T16:43:48.743570Z" } }, "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", "
idnamexy
timestamp
2000-01-01 00:00:00992Xavier-0.23-0.48
2000-01-01 00:00:01997Quinn0.570.25
2000-01-01 00:00:021034Oliver-0.710.74
\n", "
" ], "text/plain": [ " id name x y\n", "timestamp \n", "2000-01-01 00:00:00 992 Xavier -0.23 -0.48\n", "2000-01-01 00:00:01 997 Quinn 0.57 0.25\n", "2000-01-01 00:00:02 1034 Oliver -0.71 0.74" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.head(3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Use Standard Pandas Operations\n", "\n", "Most common Pandas operations operate identically on Dask dataframes" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:48.746493Z", "iopub.status.busy": "2021-10-14T16:43:48.745876Z", "iopub.status.idle": "2021-10-14T16:43:48.780563Z", "shell.execute_reply": "2021-10-14T16:43:48.781252Z" } }, "outputs": [ { "data": { "text/plain": [ "Dask Series Structure:\n", "npartitions=1\n", " float64\n", " ...\n", "Name: x, dtype: float64\n", "Dask Name: sqrt, 157 tasks" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df2 = df[df.y > 0]\n", "df3 = df2.groupby('name').x.std()\n", "df3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Call `.compute()` when you want your result as a Pandas dataframe.\n", "\n", "If you started `Client()` above then you may want to watch the status page during computation." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:48.785025Z", "iopub.status.busy": "2021-10-14T16:43:48.784419Z", "iopub.status.idle": "2021-10-14T16:43:50.580701Z", "shell.execute_reply": "2021-10-14T16:43:50.578250Z" } }, "outputs": [ { "data": { "text/plain": [ "pandas.core.series.Series" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "computed_df = df3.compute()\n", "type(computed_df)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:50.588264Z", "iopub.status.busy": "2021-10-14T16:43:50.587068Z", "iopub.status.idle": "2021-10-14T16:43:50.590886Z", "shell.execute_reply": "2021-10-14T16:43:50.591372Z" } }, "outputs": [ { "data": { "text/plain": [ "name\n", "Alice 0.58\n", "Bob 0.58\n", "Charlie 0.58\n", "Dan 0.58\n", "Edith 0.58\n", " ... \n", "Victor 0.58\n", "Wendy 0.58\n", "Xavier 0.58\n", "Yvonne 0.58\n", "Zelda 0.57\n", "Name: x, Length: 26, dtype: float64" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "computed_df" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Persist data in memory\n", "\n", "If you have the available RAM for your dataset then you can persist data in memory. \n", "\n", "This allows future computations to be much faster." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:50.594791Z", "iopub.status.busy": "2021-10-14T16:43:50.594261Z", "iopub.status.idle": "2021-10-14T16:43:50.611045Z", "shell.execute_reply": "2021-10-14T16:43:50.611494Z" } }, "outputs": [], "source": [ "df = df.persist()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Time Series Operations\n", "\n", "Because we have a datetime index time-series operations work efficiently" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:50.627788Z", "iopub.status.busy": "2021-10-14T16:43:50.626954Z", "iopub.status.idle": "2021-10-14T16:43:51.330367Z", "shell.execute_reply": "2021-10-14T16:43:51.330963Z" } }, "outputs": [], "source": [ "%matplotlib inline" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:51.341565Z", "iopub.status.busy": "2021-10-14T16:43:51.340272Z", "iopub.status.idle": "2021-10-14T16:43:51.422311Z", "shell.execute_reply": "2021-10-14T16:43:51.421320Z" } }, "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", "
xy
timestamp
2000-01-01 00:00:00-4.10e-031.31e-02
2000-01-01 01:00:00-6.11e-035.08e-03
2000-01-01 02:00:00-6.51e-031.34e-02
2000-01-01 03:00:004.71e-033.44e-03
2000-01-01 04:00:001.30e-043.64e-03
\n", "
" ], "text/plain": [ " x y\n", "timestamp \n", "2000-01-01 00:00:00 -4.10e-03 1.31e-02\n", "2000-01-01 01:00:00 -6.11e-03 5.08e-03\n", "2000-01-01 02:00:00 -6.51e-03 1.34e-02\n", "2000-01-01 03:00:00 4.71e-03 3.44e-03\n", "2000-01-01 04:00:00 1.30e-04 3.64e-03" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[['x', 'y']].resample('1h').mean().head()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:51.429454Z", "iopub.status.busy": "2021-10-14T16:43:51.428870Z", "iopub.status.idle": "2021-10-14T16:43:53.619850Z", "shell.execute_reply": "2021-10-14T16:43:53.620566Z" } }, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "df[['x', 'y']].resample('24h').mean().compute().plot()" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:53.626489Z", "iopub.status.busy": "2021-10-14T16:43:53.625592Z", "iopub.status.idle": "2021-10-14T16:43:53.770229Z", "shell.execute_reply": "2021-10-14T16:43:53.770930Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/share/miniconda3/envs/dask-examples/lib/python3.8/site-packages/dask/dataframe/rolling.py:276: FutureWarning: win_type will no longer return 'freq' in a future version. Check the type of self.window instead.\n", " self._win_type = pd_roll.win_type\n", "/usr/share/miniconda3/envs/dask-examples/lib/python3.8/site-packages/dask/dataframe/rolling.py:80: FutureWarning: Index.is_all_dates is deprecated, will be removed in a future version. check index.inferred_type instead\n", " if not df.index._meta_nonempty.is_all_dates:\n" ] }, { "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", "
xy
timestamp
2000-01-01 00:00:00-0.23-0.48
2000-01-01 00:00:010.17-0.11
2000-01-01 00:00:02-0.120.17
2000-01-01 00:00:030.110.14
2000-01-01 00:00:040.250.15
\n", "
" ], "text/plain": [ " x y\n", "timestamp \n", "2000-01-01 00:00:00 -0.23 -0.48\n", "2000-01-01 00:00:01 0.17 -0.11\n", "2000-01-01 00:00:02 -0.12 0.17\n", "2000-01-01 00:00:03 0.11 0.14\n", "2000-01-01 00:00:04 0.25 0.15" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[['x', 'y']].rolling(window='24h').mean().head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Random access is cheap along the index, but must still be computed." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:53.776256Z", "iopub.status.busy": "2021-10-14T16:43:53.772970Z", "iopub.status.idle": "2021-10-14T16:43:53.887520Z", "shell.execute_reply": "2021-10-14T16:43:53.888386Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/share/miniconda3/envs/dask-examples/lib/python3.8/site-packages/dask/dataframe/indexing.py:364: FutureWarning: 'kind' argument in _maybe_cast_slice_bound is deprecated and will be removed in a future version. Do not pass it.\n", " start = index._maybe_cast_slice_bound(indexer, \"left\", \"loc\")\n", "/usr/share/miniconda3/envs/dask-examples/lib/python3.8/site-packages/dask/dataframe/indexing.py:365: FutureWarning: 'kind' argument in _maybe_cast_slice_bound is deprecated and will be removed in a future version. Do not pass it.\n", " stop = index._maybe_cast_slice_bound(indexer, \"right\", \"loc\")\n" ] }, { "data": { "text/html": [ "
Dask DataFrame Structure:
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idnamexy
npartitions=1
2000-01-05 00:00:00.000000000int64objectfloat64float64
2000-01-05 23:59:59.999999999............
\n", "
\n", "
Dask Name: loc, 31 tasks
" ], "text/plain": [ "Dask DataFrame Structure:\n", " id name x y\n", "npartitions=1 \n", "2000-01-05 00:00:00.000000000 int64 object float64 float64\n", "2000-01-05 23:59:59.999999999 ... ... ... ...\n", "Dask Name: loc, 31 tasks" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.loc['2000-01-05']" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:53.892241Z", "iopub.status.busy": "2021-10-14T16:43:53.891666Z", "iopub.status.idle": "2021-10-14T16:43:54.295252Z", "shell.execute_reply": "2021-10-14T16:43:54.296990Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/usr/share/miniconda3/envs/dask-examples/lib/python3.8/site-packages/dask/dataframe/indexing.py:364: FutureWarning: 'kind' argument in _maybe_cast_slice_bound is deprecated and will be removed in a future version. Do not pass it.\n", " start = index._maybe_cast_slice_bound(indexer, \"left\", \"loc\")\n", "/usr/share/miniconda3/envs/dask-examples/lib/python3.8/site-packages/dask/dataframe/indexing.py:365: FutureWarning: 'kind' argument in _maybe_cast_slice_bound is deprecated and will be removed in a future version. Do not pass it.\n", " stop = index._maybe_cast_slice_bound(indexer, \"right\", \"loc\")\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 31.1 ms, sys: 21.9 ms, total: 52.9 ms\n", "Wall time: 342 ms\n" ] }, { "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", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idnamexy
timestamp
2000-01-05 00:00:00986Yvonne0.13-0.48
2000-01-05 00:00:011034Ursula-0.980.94
2000-01-05 00:00:021019Victor0.74-0.15
2000-01-05 00:00:03993Xavier-0.20-0.89
2000-01-05 00:00:041001Michael0.790.56
...............
2000-01-05 23:59:55978Hannah-0.18-0.29
2000-01-05 23:59:56986Ingrid-0.150.58
2000-01-05 23:59:571074Bob-0.42-0.17
2000-01-05 23:59:581028Wendy-0.37-0.03
2000-01-05 23:59:59969Alice-0.380.97
\n", "

86400 rows × 4 columns

\n", "
" ], "text/plain": [ " id name x y\n", "timestamp \n", "2000-01-05 00:00:00 986 Yvonne 0.13 -0.48\n", "2000-01-05 00:00:01 1034 Ursula -0.98 0.94\n", "2000-01-05 00:00:02 1019 Victor 0.74 -0.15\n", "2000-01-05 00:00:03 993 Xavier -0.20 -0.89\n", "2000-01-05 00:00:04 1001 Michael 0.79 0.56\n", "... ... ... ... ...\n", "2000-01-05 23:59:55 978 Hannah -0.18 -0.29\n", "2000-01-05 23:59:56 986 Ingrid -0.15 0.58\n", "2000-01-05 23:59:57 1074 Bob -0.42 -0.17\n", "2000-01-05 23:59:58 1028 Wendy -0.37 -0.03\n", "2000-01-05 23:59:59 969 Alice -0.38 0.97\n", "\n", "[86400 rows x 4 columns]" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%time df.loc['2000-01-05'].compute()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Set Index\n", "\n", "Data is sorted by the index column. This allows for faster access, joins, groupby-apply operations, etc.. However sorting data can be costly to do in parallel, so setting the index is both important to do, but only infrequently." ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:54.302507Z", "iopub.status.busy": "2021-10-14T16:43:54.301739Z", "iopub.status.idle": "2021-10-14T16:43:57.712545Z", "shell.execute_reply": "2021-10-14T16:43:57.713513Z" } }, "outputs": [ { "data": { "text/html": [ "
Dask DataFrame Structure:
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idxy
npartitions=30
Aliceint64float64float64
Alice.........
............
Zelda.........
Zelda.........
\n", "
\n", "
Dask Name: sort_index, 1140 tasks
" ], "text/plain": [ "Dask DataFrame Structure:\n", " id x y\n", "npartitions=30 \n", "Alice int64 float64 float64\n", "Alice ... ... ...\n", "... ... ... ...\n", "Zelda ... ... ...\n", "Zelda ... ... ...\n", "Dask Name: sort_index, 1140 tasks" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df = df.set_index('name')\n", "df" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Because computing this dataset is expensive and we can fit it in our available RAM, we persist the dataset to memory." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:57.717143Z", "iopub.status.busy": "2021-10-14T16:43:57.715742Z", "iopub.status.idle": "2021-10-14T16:43:57.823641Z", "shell.execute_reply": "2021-10-14T16:43:57.823042Z" } }, "outputs": [], "source": [ "df = df.persist()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dask now knows where all data lives, indexed cleanly by name. As a result oerations like random access are cheap and efficient" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:43:57.832528Z", "iopub.status.busy": "2021-10-14T16:43:57.831560Z", "iopub.status.idle": "2021-10-14T16:44:01.135753Z", "shell.execute_reply": "2021-10-14T16:44:01.134028Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 471 ms, sys: 29.1 ms, total: 500 ms\n", "Wall time: 3.27 s\n" ] }, { "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", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idxy
name
Alice978-0.720.16
Alice978-0.83-0.96
Alice1037-0.520.08
Alice10110.85-0.93
Alice9880.93-0.21
............
Alice1028-0.640.13
Alice9950.89-0.46
Alice1010-0.940.89
Alice9890.19-0.43
Alice9870.980.82
\n", "

99228 rows × 3 columns

\n", "
" ], "text/plain": [ " id x y\n", "name \n", "Alice 978 -0.72 0.16\n", "Alice 978 -0.83 -0.96\n", "Alice 1037 -0.52 0.08\n", "Alice 1011 0.85 -0.93\n", "Alice 988 0.93 -0.21\n", "... ... ... ...\n", "Alice 1028 -0.64 0.13\n", "Alice 995 0.89 -0.46\n", "Alice 1010 -0.94 0.89\n", "Alice 989 0.19 -0.43\n", "Alice 987 0.98 0.82\n", "\n", "[99228 rows x 3 columns]" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%time df.loc['Alice'].compute()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Groupby Apply with Scikit-Learn" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that our data is sorted by name we can easily do operations like random access on name, or groupby-apply with custom functions.\n", "\n", "Here we train a different Scikit-Learn linear regression model on each name." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:44:01.142491Z", "iopub.status.busy": "2021-10-14T16:44:01.141123Z", "iopub.status.idle": "2021-10-14T16:44:02.273187Z", "shell.execute_reply": "2021-10-14T16:44:02.273834Z" } }, "outputs": [], "source": [ "from sklearn.linear_model import LinearRegression\n", "\n", "def train(partition):\n", " est = LinearRegression()\n", " est.fit(partition[['x']].values, partition.y.values)\n", " return est" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "execution": { "iopub.execute_input": "2021-10-14T16:44:02.283808Z", "iopub.status.busy": "2021-10-14T16:44:02.282431Z", "iopub.status.idle": "2021-10-14T16:44:05.637380Z", "shell.execute_reply": "2021-10-14T16:44:05.640129Z" } }, "outputs": [ { "data": { "text/plain": [ "name\n", "Alice LinearRegression()\n", "Bob LinearRegression()\n", "Charlie LinearRegression()\n", "Dan LinearRegression()\n", "Edith LinearRegression()\n", " ... \n", "Victor LinearRegression()\n", "Wendy LinearRegression()\n", "Xavier LinearRegression()\n", "Yvonne LinearRegression()\n", "Zelda LinearRegression()\n", "Length: 26, dtype: object" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.groupby('name').apply(train, meta=object).compute()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Further Reading\n", "\n", "For a more in-depth introduction to Dask dataframes, see the [dask tutorial](https://github.com/dask/dask-tutorial), notebooks 04 and 07." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.12" } }, "nbformat": 4, "nbformat_minor": 2 }