├── 1-Futures.ipynb ├── 2-Dataframes.ipynb ├── README.md ├── binder ├── environment.yml ├── jupyterlab-workspace.json └── start ├── images └── nyc-taxi-scatter.png └── requirements.txt /1-Futures.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "3786371b-cdd0-473b-89bd-94573b3676b5", 6 | "metadata": {}, 7 | "source": [ 8 | "\"Dask\n", 12 | " \n", 13 | "# Parallelize Python with
Dask Futures\n", 14 | "\n", 15 | "In this lesson, we will take normal for-loopy Python code that looks like this:\n", 16 | "\n", 17 | "```python\n", 18 | "urls = [...]\n", 19 | "results = []\n", 20 | "for url in urls:\n", 21 | " page = download(url)\n", 22 | " result = process(page)\n", 23 | " results.append(result)\n", 24 | "```\n", 25 | "\n", 26 | "or more dynamic Python code that looks like this:\n", 27 | "\n", 28 | "```python\n", 29 | "urls = [...]\n", 30 | "results = []\n", 31 | "while urls:\n", 32 | " url = urls.pop()\n", 33 | " page = download(url)\n", 34 | " result = process(page)\n", 35 | " results.append(result)\n", 36 | " \n", 37 | " new_urls = scrape(page)\n", 38 | " urls.extend(new_urls)\n", 39 | "```\n", 40 | "\n", 41 | "and parallelize it out into a dynamic task graph (image right) and then run that code in parallel. \n", 42 | "\n", 43 | "This will give us the foundation of parallel computing used by Dask. In future examples, we'll see how other library developers have used this to give us higher-level parallel APIs .\n" 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "id": "e5eca4d3-0a1a-4b30-946b-676fa0daa32b", 49 | "metadata": {}, 50 | "source": [ 51 | "\n", 52 | "\n", 53 | "## Outline\n", 54 | "\n", 55 | "We will learn how to use futures, and then use them on a real-world example, first in a simple case, and then in a complex case:\n", 56 | "\n", 57 | "1. (Learn) How to use Futures \n", 58 | "2. (Do) Use futures to download and parse webpages\n", 59 | "3. (Learn) Dynamic/changing workloads\n", 60 | "4. (Do) Crawl and scrape a website\n", 61 | "\n" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "id": "c1810a74-7c2b-41bd-b795-3b1a9aba71b7", 67 | "metadata": {}, 68 | "source": [ 69 | "\n", 70 | "## 1. (Learn) How to use Futures\n", 71 | "\n" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "id": "80a6e52b-c243-43e9-b255-bd60d6f142ca", 77 | "metadata": { 78 | "tags": [] 79 | }, 80 | "source": [ 81 | "### Parallel Code with low-level Futures\n", 82 | "\n", 83 | "This is an example of an embarrassingly parallel computation. We want to run the same Python code on many pieces of data. This is a very simple and also very common case that comes up all the time.\n", 84 | "\n", 85 | "Let's learn how to do this with [Dask futures](https://docs.dask.org/en/stable/futures.html)\n", 86 | "\n", 87 | "First, we're going to see a very simple example, then we'll try to parallelize the code above.\n" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "id": "01cf74da-c8d7-402a-ab4e-09785061c70e", 93 | "metadata": {}, 94 | "source": [ 95 | "### Set up a Dask cluster locally" 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": null, 101 | "id": "f512e342-4446-4b23-ab78-7d6bb4405e77", 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [ 105 | "from dask.distributed import Client\n", 106 | "\n", 107 | "client = Client()\n", 108 | "client" 109 | ] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "id": "8f4478ef-fc35-4e26-a1de-7ecd690ead1f", 114 | "metadata": {}, 115 | "source": [ 116 | "### Dask Futures introduction" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "id": "d7e89388-eea3-4c66-ae63-ebe792806f5c", 123 | "metadata": {}, 124 | "outputs": [], 125 | "source": [ 126 | "import time\n", 127 | "import random\n", 128 | "\n", 129 | "def inc(x):\n", 130 | " time.sleep(random.random())\n", 131 | " return x + 1\n", 132 | "\n", 133 | "def double(x):\n", 134 | " time.sleep(random.random())\n", 135 | " return 2 * x\n", 136 | "\n", 137 | "def add(x, y):\n", 138 | " time.sleep(random.random())\n", 139 | " return 2 * x\n", 140 | " " 141 | ] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "id": "491cc8d1-1a37-4d3f-b9ab-fa27d6283771", 146 | "metadata": {}, 147 | "source": [ 148 | "Dask futures lets us run Python functions remotely on parallel hardware. Rather than calling the function directly:" 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": null, 154 | "id": "784cdc94-c20c-4d4a-93c8-5f390671fa18", 155 | "metadata": {}, 156 | "outputs": [], 157 | "source": [ 158 | "%%time\n", 159 | "\n", 160 | "y = inc(10)\n", 161 | "z = double(y)\n", 162 | "z" 163 | ] 164 | }, 165 | { 166 | "cell_type": "markdown", 167 | "id": "be50d006-c1c3-4796-9240-9b42048f09be", 168 | "metadata": {}, 169 | "source": [ 170 | "We can ask Dask to run that function, `slowinc` on the data `10` by passing each as arguments into the `client.submit` method. The first argument is the function to call and the rest of the arguments are arguments to that function.\n", 171 | "\n", 172 | "Normal Execution\n", 173 | "\n", 174 | "```python\n", 175 | "result = function(*args, **kwargs)\n", 176 | "```\n", 177 | "\n", 178 | "Submit function for remote execution\n", 179 | "\n", 180 | "```python\n", 181 | "future = client.submit(function, *args, **kwargs) # instantaneously fire off work\n", 182 | "...\n", 183 | "result = future.result() # when we need, block until done and collect the result\n", 184 | "```" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "id": "acbde717-4779-4679-b21a-e7e46b8a8ea9", 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [ 194 | "%%time\n", 195 | "\n", 196 | "y = client.submit(inc, 10)\n", 197 | "z = client.submit(double, y)\n", 198 | "z" 199 | ] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "id": "2bb7b612-e8e6-4df9-8931-291e1c4e37d1", 204 | "metadata": {}, 205 | "source": [ 206 | "You'll notice that that happened immediately. That's because all we did was submit the `inc` function to run on Dask, and then return a `Future`, or a pointer to where the data will eventually be.\n", 207 | "\n", 208 | "We can gather the future by calling `future.result()`" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": null, 214 | "id": "d19b2bb0-8d16-4fc7-bf34-f62272c8bdf9", 215 | "metadata": {}, 216 | "outputs": [], 217 | "source": [ 218 | "z" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "id": "92857028-91f6-4c52-8ded-1b90824ff591", 225 | "metadata": {}, 226 | "outputs": [], 227 | "source": [ 228 | "z.result()" 229 | ] 230 | }, 231 | { 232 | "cell_type": "markdown", 233 | "id": "41f0e330-f7da-43c5-b14c-fb23ea527663", 234 | "metadata": {}, 235 | "source": [ 236 | "### Submit many tasks in a loop\n", 237 | "\n", 238 | "We can submit lots of functions to run at once, and then gather them when we're done. This allows us to easily parallelize simple for loops.\n", 239 | "\n", 240 | "*This section uses the following API*:\n", 241 | "\n", 242 | "- [Client.submit and Future.result](https://docs.dask.org/en/stable/futures.html#submit-tasks)\n" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "id": "cc323bbf-fadb-4ced-8cc5-ac4434de93f5", 248 | "metadata": {}, 249 | "source": [ 250 | "#### Sequential code" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": null, 256 | "id": "27af5073-7276-477b-8a26-7b87e58c7e93", 257 | "metadata": {}, 258 | "outputs": [], 259 | "source": [ 260 | "%%time \n", 261 | "\n", 262 | "data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", 263 | "results = []\n", 264 | "\n", 265 | "for x in data:\n", 266 | " y = inc(x)\n", 267 | " z = double(y)\n", 268 | " results.append(z)\n", 269 | " \n", 270 | "results" 271 | ] 272 | }, 273 | { 274 | "cell_type": "markdown", 275 | "id": "1426a61d-971f-44df-bfc0-21806d3d673d", 276 | "metadata": {}, 277 | "source": [ 278 | "#### Parallel code" 279 | ] 280 | }, 281 | { 282 | "cell_type": "code", 283 | "execution_count": null, 284 | "id": "684ecb0c-9dc8-4aaf-af84-3d3114ca9fe6", 285 | "metadata": { 286 | "jupyter": { 287 | "source_hidden": true 288 | }, 289 | "tags": [] 290 | }, 291 | "outputs": [], 292 | "source": [ 293 | "%%time \n", 294 | "\n", 295 | "data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", 296 | "results = []\n", 297 | "\n", 298 | "for x in data:\n", 299 | " y = client.submit(inc, x)\n", 300 | " z = client.submit(double, y)\n", 301 | " results.append(z)\n", 302 | " \n", 303 | "results = client.gather(results)\n", 304 | "results" 305 | ] 306 | }, 307 | { 308 | "cell_type": "markdown", 309 | "id": "e5675eb0-5533-457e-9ee1-da574300dc9c", 310 | "metadata": {}, 311 | "source": [ 312 | "### Lessons:\n", 313 | "\n", 314 | "1. Submit a function to run elsewhere\n", 315 | "\n", 316 | " ```python\n", 317 | " y = f(x)\n", 318 | " future = client.submit(f, x)\n", 319 | " ```\n", 320 | " \n", 321 | " \n", 322 | "2. Get results when you're done\n", 323 | "\n", 324 | " ```python\n", 325 | " y = future.result()\n", 326 | " # or \n", 327 | " results = client.gather(futures)\n", 328 | " ```" 329 | ] 330 | }, 331 | { 332 | "cell_type": "markdown", 333 | "id": "2d4cc17e-25c1-4fef-a0a4-697bf67fa099", 334 | "metadata": { 335 | "tags": [] 336 | }, 337 | "source": [ 338 | "## 2. (Do) Use futures to download and parse webpages\n", 339 | "\n", 340 | "### Sequential Code\n", 341 | "\n", 342 | "The code below downloads 50 question pages from a Stack Overflow tag, parses those pages, and collects the title and list of tags from each page.\n", 343 | "\n", 344 | "We then count up all the tags to see what are the most popular kinds of questions. We divide this code into four sections:\n", 345 | "\n", 346 | "1. Define useful functions\n", 347 | "2. Get a list of pages to download and scrape\n", 348 | "3. Download and scrape\n", 349 | "4. Analyze results" 350 | ] 351 | }, 352 | { 353 | "cell_type": "markdown", 354 | "id": "93e385ba-320b-49c3-8e82-eaec3c190750", 355 | "metadata": {}, 356 | "source": [ 357 | "#### Define useful functions\n", 358 | "\n", 359 | "You don't need to study these. Feel free to skip." 360 | ] 361 | }, 362 | { 363 | "cell_type": "code", 364 | "execution_count": null, 365 | "id": "d68476f8-ab20-4f34-b3a2-e5a063c39835", 366 | "metadata": {}, 367 | "outputs": [], 368 | "source": [ 369 | "import re\n", 370 | "import requests\n", 371 | "from bs4 import BeautifulSoup\n", 372 | "import time\n", 373 | "\n", 374 | "def download(url: str, delay=0) -> str:\n", 375 | " time.sleep(delay)\n", 376 | " response = requests.get(url)\n", 377 | " if response.status_code == 200:\n", 378 | " return response.text\n", 379 | " else:\n", 380 | " response.raise_for_status()\n", 381 | " \n", 382 | " \n", 383 | "def scrape_title(body: str) -> str:\n", 384 | " html = BeautifulSoup(body, \"html.parser\")\n", 385 | " return str(html.html.title)\n", 386 | "\n", 387 | "\n", 388 | "def scrape_links(body: str, base_url=\"\") -> list[str]:\n", 389 | " html = BeautifulSoup(body, \"html.parser\")\n", 390 | " \n", 391 | " return [\n", 392 | " str(base_url + link.attrs[\"href\"]).split(\"?\")[0]\n", 393 | " for link in html.find_all(\"a\") \n", 394 | " if re.match(\"/questions/\\d{5}\", link.attrs.get(\"href\", \"\"))\n", 395 | " ]\n", 396 | "\n", 397 | "\n", 398 | "def scrape_tags(body: str) -> list[str]:\n", 399 | " html = BeautifulSoup(body, \"html.parser\")\n", 400 | " \n", 401 | " return sorted({\n", 402 | " str(list(link.children)[0])\n", 403 | " for link in html.find_all(\"a\", class_=\"post-tag\")\n", 404 | " })" 405 | ] 406 | }, 407 | { 408 | "cell_type": "markdown", 409 | "id": "c55e8b99-ce1b-4c0d-8c9d-6e9db2b47339", 410 | "metadata": {}, 411 | "source": [ 412 | "#### Get list of pages to download and scrape" 413 | ] 414 | }, 415 | { 416 | "cell_type": "code", 417 | "execution_count": null, 418 | "id": "a4da310d-aab4-4e52-8597-77dc8a6432e5", 419 | "metadata": {}, 420 | "outputs": [], 421 | "source": [ 422 | "url = \"https://stackoverflow.com/questions/tagged/jupyter\"\n", 423 | "body = download(url)\n", 424 | "urls = scrape_links(body, base_url=\"https://stackoverflow.com\")\n", 425 | "urls[:5]" 426 | ] 427 | }, 428 | { 429 | "cell_type": "markdown", 430 | "id": "b0fae6d1-d0e2-46df-b130-e13655d8d981", 431 | "metadata": {}, 432 | "source": [ 433 | "#### Download and scrape" 434 | ] 435 | }, 436 | { 437 | "cell_type": "code", 438 | "execution_count": null, 439 | "id": "a7ee1f7d-f0de-42a0-b99d-173103a39b20", 440 | "metadata": {}, 441 | "outputs": [], 442 | "source": [ 443 | "%%time\n", 444 | "\n", 445 | "all_tags = []\n", 446 | "titles = []\n", 447 | "\n", 448 | "for url in urls:\n", 449 | " page = download(url)\n", 450 | " print(\".\", end=\"\")\n", 451 | " tags = scrape_tags(page)\n", 452 | " title = scrape_title(page)\n", 453 | " \n", 454 | " all_tags.append(tags)\n", 455 | " titles.append(title)\n", 456 | "print()" 457 | ] 458 | }, 459 | { 460 | "cell_type": "markdown", 461 | "id": "199ed8c4-9f9e-47bd-9ac9-a6453729c6a9", 462 | "metadata": {}, 463 | "source": [ 464 | "#### Analyze Results\n", 465 | "\n", 466 | "Aggregate tags to find related topics" 467 | ] 468 | }, 469 | { 470 | "cell_type": "code", 471 | "execution_count": null, 472 | "id": "bba06861-4b0d-4e21-af30-875129713d83", 473 | "metadata": {}, 474 | "outputs": [], 475 | "source": [ 476 | "import collections\n", 477 | "\n", 478 | "tag_counter = collections.defaultdict(int)\n", 479 | "\n", 480 | "for tags in all_tags:\n", 481 | " for tag in tags:\n", 482 | " tag_counter[tag] += 1\n", 483 | " \n", 484 | "sorted(tag_counter.items(), key=lambda kv: kv[1], reverse=True)[:10]" 485 | ] 486 | }, 487 | { 488 | "cell_type": "markdown", 489 | "id": "55a5f41f-ad62-4503-ad1c-ab68d9a9869c", 490 | "metadata": {}, 491 | "source": [ 492 | "### Exercise: Parallelize this code\n", 493 | "\n", 494 | "Take the code above, and use Dask futures to run it in parallel\n", 495 | "\n", 496 | "Which sections should we think about parallelizing?" 497 | ] 498 | }, 499 | { 500 | "cell_type": "code", 501 | "execution_count": null, 502 | "id": "bd3e7682-7220-480a-9ca3-4278a5383e8c", 503 | "metadata": {}, 504 | "outputs": [], 505 | "source": [ 506 | "url = \"https://stackoverflow.com/questions/tagged/jupyter\"\n", 507 | "body = download(url)\n", 508 | "urls = scrape_links(body, base_url=\"https://stackoverflow.com\")" 509 | ] 510 | }, 511 | { 512 | "cell_type": "code", 513 | "execution_count": null, 514 | "id": "91f71522-5808-4950-92a5-f25bdc769a29", 515 | "metadata": {}, 516 | "outputs": [], 517 | "source": [ 518 | "# TODO: parallelize me\n", 519 | "\n", 520 | "%%time\n", 521 | "\n", 522 | "all_tags = []\n", 523 | "titles = []\n", 524 | "\n", 525 | "for url in urls:\n", 526 | " page = download(url)\n", 527 | " print(\".\", end=\"\")\n", 528 | " tags = scrape_tags(page)\n", 529 | " title = scrape_title(page)\n", 530 | " \n", 531 | " all_tags.append(tags)\n", 532 | " titles.append(title)\n", 533 | "print()" 534 | ] 535 | }, 536 | { 537 | "cell_type": "markdown", 538 | "id": "5a430e17-5bca-4b48-b914-95657515867e", 539 | "metadata": { 540 | "tags": [] 541 | }, 542 | "source": [ 543 | "##### Solution\n", 544 | "\n", 545 | "Expand the three dots below if you want to see the answer" 546 | ] 547 | }, 548 | { 549 | "cell_type": "code", 550 | "execution_count": null, 551 | "id": "1da9e012-31dc-4339-ab33-5ea38712ad65", 552 | "metadata": { 553 | "jupyter": { 554 | "source_hidden": true 555 | }, 556 | "tags": [] 557 | }, 558 | "outputs": [], 559 | "source": [ 560 | "%%time\n", 561 | "\n", 562 | "all_tags = []\n", 563 | "titles = []\n", 564 | "\n", 565 | "for url in urls:\n", 566 | " page = client.submit(download, url)\n", 567 | " tags = client.submit(scrape_tags, page)\n", 568 | " title = client.submit(scrape_title, page)\n", 569 | " \n", 570 | " all_tags.append(tags)\n", 571 | " titles.append(title)\n", 572 | " \n", 573 | "all_tags = client.gather(all_tags)\n", 574 | "titles = client.gather(titles)" 575 | ] 576 | }, 577 | { 578 | "cell_type": "code", 579 | "execution_count": null, 580 | "id": "0f5df132-43d8-40ce-934e-eb0735a86519", 581 | "metadata": {}, 582 | "outputs": [], 583 | "source": [ 584 | "import collections\n", 585 | "\n", 586 | "tag_counter = collections.defaultdict(int)\n", 587 | "\n", 588 | "for tags in all_tags:\n", 589 | " for tag in tags:\n", 590 | " tag_counter[tag] += 1\n", 591 | " \n", 592 | "sorted(tag_counter.items(), key=lambda kv: kv[1], reverse=True)[:10]" 593 | ] 594 | }, 595 | { 596 | "cell_type": "markdown", 597 | "id": "648048f6-53d8-4e64-a0cf-f3aa5c841ed6", 598 | "metadata": {}, 599 | "source": [ 600 | "### Exercise: Scale out\n", 601 | "\n", 602 | "There are different reasons to scale out for this problem:\n", 603 | "\n", 604 | "1. Parallelize bandwidth\n", 605 | "2. StackOverflow's rate-limits won't affect us as much if we spread out our requests from many different machines\n", 606 | "3. ~CPU Processing speed~ (not really an issue here)\n", 607 | "\n", 608 | "Let's ask for some machines from Coiled, and switch our Dask client to use that cluster." 609 | ] 610 | }, 611 | { 612 | "cell_type": "code", 613 | "execution_count": null, 614 | "id": "f57c5ed2-5103-4811-b1ee-781046c16649", 615 | "metadata": {}, 616 | "outputs": [], 617 | "source": [ 618 | "client.close()" 619 | ] 620 | }, 621 | { 622 | "cell_type": "code", 623 | "execution_count": null, 624 | "id": "4ded7332-a475-40f6-a7b2-01f017573c35", 625 | "metadata": { 626 | "tags": [] 627 | }, 628 | "outputs": [], 629 | "source": [ 630 | "import coiled\n", 631 | "\n", 632 | "cluster = coiled.Cluster(\n", 633 | " n_workers=20,\n", 634 | " worker_cpu=2,\n", 635 | " worker_options={\"nthreads\": 1},\n", 636 | " account=\"dask-tutorials\",\n", 637 | ")\n", 638 | "\n", 639 | "client = cluster.get_client()" 640 | ] 641 | }, 642 | { 643 | "attachments": { 644 | "dbc8e0aa-6a12-436a-aef4-f8253b1739d7.png": { 645 | "image/png": "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" 646 | } 647 | }, 648 | "cell_type": "markdown", 649 | "id": "92acc786-81bd-49cd-867f-66b3346d0890", 650 | "metadata": {}, 651 | "source": [ 652 | "You can then insert the Dashboard URL into the text field at the top of the Dask JupyterLab extension sidebar, or press the Magnifying Glass icon (🔍) in the upper right of that section.\n", 653 | "\n", 654 | "This will change your dashboard plots to the new cluster.\n", 655 | "\n", 656 | "![Screen Shot 2023-05-08 at 10.36.36 AM.png](attachment:dbc8e0aa-6a12-436a-aef4-f8253b1739d7.png)" 657 | ] 658 | }, 659 | { 660 | "cell_type": "markdown", 661 | "id": "4a1d539e-b1ba-467f-bb13-b8b3a4168778", 662 | "metadata": {}, 663 | "source": [ 664 | "Now rerun your computation and see how it feels." 665 | ] 666 | }, 667 | { 668 | "cell_type": "markdown", 669 | "id": "ba1bd389-7495-48be-9efb-78b4a3e46415", 670 | "metadata": {}, 671 | "source": [ 672 | "## 3. (Learn) Evolving computations\n", 673 | "\n", 674 | "Dask futures are flexible. There are many ways to coordinate them including ...\n", 675 | "\n", 676 | "1. Distributed locks and semaphores\n", 677 | "2. Distributed queues\n", 678 | "3. Launching tasks from tasks\n", 679 | "4. Global variables\n", 680 | "5. ... [and lots more](https://docs.dask.org/en/stable/futures.html)\n", 681 | "\n", 682 | "We're going to get a taste of this by learning about one Dask futures feature, [`as_completed`](https://docs.dask.org/en/stable/futures.html#distributed.as_completed), which lets us dynamically build up a computation as it completes.\n", 683 | "\n", 684 | "We will use this to build a parallel web crawler over Stack Overflow. \n", 685 | "\n", 686 | "1. First, we'll build this sequentially.\n", 687 | "2. Second, we'll learn how `as_completed` works in a simple example\n", 688 | "3. Third, we'll convert the sequential code into parallel code" 689 | ] 690 | }, 691 | { 692 | "cell_type": "markdown", 693 | "id": "9b814665-7240-43ae-95f9-6fa860da8c2f", 694 | "metadata": {}, 695 | "source": [ 696 | "### Sequential Code to Crawl Stack Overflow" 697 | ] 698 | }, 699 | { 700 | "cell_type": "code", 701 | "execution_count": null, 702 | "id": "7350e302-f792-448d-bc41-4afd0bf527ad", 703 | "metadata": { 704 | "tags": [] 705 | }, 706 | "outputs": [], 707 | "source": [ 708 | "%%time\n", 709 | "from collections import deque\n", 710 | "\n", 711 | "urls = deque()\n", 712 | "urls.append(\"https://stackoverflow.com/questions/tagged/dask\") # seed with a single page\n", 713 | "\n", 714 | "all_tags = []\n", 715 | "titles = []\n", 716 | "seen = set()\n", 717 | "i = 0\n", 718 | "\n", 719 | "while urls and i < 10:\n", 720 | " url = urls.popleft()\n", 721 | " \n", 722 | " # Don't scrape the same page twice\n", 723 | " if url in seen: \n", 724 | " continue\n", 725 | " else:\n", 726 | " seen.add(url)\n", 727 | " \n", 728 | " print(\".\", end=\"\")\n", 729 | " i += 1\n", 730 | " \n", 731 | " # This is like before\n", 732 | " page = download(url)\n", 733 | " tags = scrape_tags(page)\n", 734 | " title = scrape_title(page)\n", 735 | " all_tags.append(tags)\n", 736 | " titles.append(title)\n", 737 | "\n", 738 | " # This is new! \n", 739 | " # We scrape links on this page, and add them to the list of URLs\n", 740 | " new_urls = scrape_links(page, base_url=\"https://stackoverflow.com\")\n", 741 | " urls.extend(new_urls)" 742 | ] 743 | }, 744 | { 745 | "cell_type": "code", 746 | "execution_count": null, 747 | "id": "1239abe4-3c3e-44f0-a0dd-825b9520360e", 748 | "metadata": { 749 | "tags": [] 750 | }, 751 | "outputs": [], 752 | "source": [ 753 | "titles" 754 | ] 755 | }, 756 | { 757 | "cell_type": "code", 758 | "execution_count": null, 759 | "id": "f18c4b87-5dd3-41b3-9856-2c79f00d3aa5", 760 | "metadata": { 761 | "tags": [] 762 | }, 763 | "outputs": [], 764 | "source": [ 765 | "all_tags" 766 | ] 767 | }, 768 | { 769 | "cell_type": "markdown", 770 | "id": "1a919f2b-1fe2-44dd-b3e6-36eb8c08756a", 771 | "metadata": {}, 772 | "source": [ 773 | "### Learn about `as_completed`\n", 774 | "\n", 775 | "Let's use our `inc`/`dec` example from before, and add up the results as they come in." 776 | ] 777 | }, 778 | { 779 | "cell_type": "code", 780 | "execution_count": null, 781 | "id": "be90ffe7-27e1-4178-8bb1-49c5b7f9a70a", 782 | "metadata": {}, 783 | "outputs": [], 784 | "source": [ 785 | "%%time \n", 786 | "\n", 787 | "total = 0\n", 788 | "\n", 789 | "for x in range(16):\n", 790 | " y = inc(x)\n", 791 | " z = double(y)\n", 792 | " total += z\n", 793 | " print(\"Total:\", total, end=\"\\r\")" 794 | ] 795 | }, 796 | { 797 | "cell_type": "markdown", 798 | "id": "8d44ceb1-c433-481e-aaa4-0af038277206", 799 | "metadata": {}, 800 | "source": [ 801 | "When we want to change our computation on the fly the `as_completed` object becomes useful. It has the following API:\n", 802 | "\n", 803 | "```python\n", 804 | "ac = as_completed()\n", 805 | "\n", 806 | "# add futures to as_completed\n", 807 | "ac.add(future_1)\n", 808 | "ac.add(future_2)\n", 809 | "ac.add(future_3)\n", 810 | "\n", 811 | "# block until any of them finish\n", 812 | "future = ac.next()\n", 813 | "```\n", 814 | "\n", 815 | "You can add futures any time, and pull futures off any time. Futures will always be finished when then emerge from the `as_completed` object." 816 | ] 817 | }, 818 | { 819 | "cell_type": "code", 820 | "execution_count": null, 821 | "id": "357dff8d-836d-436b-91b7-f5a0a0f87765", 822 | "metadata": {}, 823 | "outputs": [], 824 | "source": [ 825 | "%%time \n", 826 | "\n", 827 | "from dask.distributed import as_completed\n", 828 | "\n", 829 | "total = 0\n", 830 | "futures = as_completed()\n", 831 | "\n", 832 | "for x in range(200):\n", 833 | " y = client.submit(inc, x)\n", 834 | " z = client.submit(double, y)\n", 835 | " futures.add(z)\n", 836 | "\n", 837 | "while futures.count() > 1:\n", 838 | " a = futures.next()\n", 839 | " b = futures.next()\n", 840 | " c = client.submit(add, a, b, priority=1)\n", 841 | " futures.add(c)\n", 842 | " print(\"Some results:\", a.result(), b.result(), end=\"\\r\")\n", 843 | " \n", 844 | "total = futures.next().result()\n", 845 | "print(\"Final Result:\", total)" 846 | ] 847 | }, 848 | { 849 | "cell_type": "markdown", 850 | "id": "e82279ad-3352-4664-b351-f3690e05a819", 851 | "metadata": {}, 852 | "source": [ 853 | "## 4. (Do): Parallelize code to crawl Stack Overflow" 854 | ] 855 | }, 856 | { 857 | "cell_type": "markdown", 858 | "id": "b9202ed6-55c5-4575-a1d1-f48e439498e4", 859 | "metadata": {}, 860 | "source": [ 861 | "#### Difficulty: Hard\n", 862 | "\n", 863 | "Expand the sequential code that we saw below. Parallelize it with futures and `as_completed`.\n", 864 | "\n", 865 | "If it's too hard, consider the option below to get some hints." 866 | ] 867 | }, 868 | { 869 | "cell_type": "code", 870 | "execution_count": null, 871 | "id": "fab394ec-bd8b-458e-b340-51b275050fad", 872 | "metadata": { 873 | "jupyter": { 874 | "source_hidden": true 875 | }, 876 | "tags": [] 877 | }, 878 | "outputs": [], 879 | "source": [ 880 | "%%time\n", 881 | "from collections import deque\n", 882 | "\n", 883 | "urls = deque()\n", 884 | "urls.append(\"https://stackoverflow.com/questions/tagged/dask\") # seed with a single page\n", 885 | "\n", 886 | "all_tags = []\n", 887 | "titles = []\n", 888 | "seen = set()\n", 889 | "i = 0\n", 890 | "\n", 891 | "while urls and i < 10:\n", 892 | " url = urls.popleft()\n", 893 | " \n", 894 | " # Don't scrape the same page twice\n", 895 | " if url in seen: \n", 896 | " continue\n", 897 | " else:\n", 898 | " seen.add(url)\n", 899 | " \n", 900 | " print(\".\", end=\"\")\n", 901 | " i += 1\n", 902 | " \n", 903 | " # This is like before\n", 904 | " page = download(url, delay=0.25)\n", 905 | " tags = scrape_tags(page)\n", 906 | " title = scrape_title(page)\n", 907 | " all_tags.append(tags)\n", 908 | " titles.append(title)\n", 909 | "\n", 910 | " # This is new! \n", 911 | " # We scrape links on this page, and add them to the list of URLs\n", 912 | " new_urls = scrape_question_links(page, base_url=\"https://stackoverflow.com\")\n", 913 | " urls.extend(new_urls)" 914 | ] 915 | }, 916 | { 917 | "cell_type": "markdown", 918 | "id": "6233dcc7-ac22-4916-a67e-ac2996fc3d54", 919 | "metadata": {}, 920 | "source": [ 921 | "#### Difficulty: Medium\n", 922 | "\n", 923 | "Expand the cell below to get hints about how to proceed" 924 | ] 925 | }, 926 | { 927 | "cell_type": "code", 928 | "execution_count": null, 929 | "id": "feefb51d-82c7-41f4-84c5-8b15a277a54c", 930 | "metadata": { 931 | "jupyter": { 932 | "source_hidden": true 933 | }, 934 | "tags": [] 935 | }, 936 | "outputs": [], 937 | "source": [ 938 | "%%time\n", 939 | "from collections import deque\n", 940 | "from dask.distributed import as_completed\n", 941 | "\n", 942 | "urls = deque()\n", 943 | "urls.append(\"https://stackoverflow.com/questions/tagged/jupyter\") # seed with a single page\n", 944 | "\n", 945 | "all_tags = []\n", 946 | "titles = []\n", 947 | "url_futures = as_completed()\n", 948 | "seen = set()\n", 949 | "i = 0\n", 950 | "\n", 951 | "while urls or not url_futures.is_empty() and i < 1000: \n", 952 | " # TODO: If urls is empty, \n", 953 | " # get the next future from url_futures\n", 954 | " # collect those new url results to the local notebook\n", 955 | " # and add those new urls to urls\n", 956 | " \n", 957 | " url = urls.popleft()\n", 958 | " \n", 959 | " if url in seen:\n", 960 | " continue\n", 961 | " else:\n", 962 | " seen.add(url)\n", 963 | " \n", 964 | " print(\".\", end=\"\")\n", 965 | " i += 1\n", 966 | "\n", 967 | " # This is like before\n", 968 | " # TODO: Submit this work to happen in parallel\n", 969 | " page = download(url, delay=0.25)\n", 970 | " tags = scrape_tags(page)\n", 971 | " title = scrape_title(page)\n", 972 | " \n", 973 | " all_tags.append(tags)\n", 974 | " titles.append(title)\n", 975 | "\n", 976 | " # We scrape links on this page, and add them to the list of URLs\n", 977 | " # TODO: Submit this work to happen in parallel. Add the future to url_futures\n", 978 | " new_urls = scrape_question_links(page, base_url=\"https://stackoverflow.com\")\n", 979 | " urls.extend(new_urls)" 980 | ] 981 | }, 982 | { 983 | "cell_type": "markdown", 984 | "id": "d41829cc-9405-47d7-8ee1-35c9fc51bcd0", 985 | "metadata": {}, 986 | "source": [ 987 | "#### Difficulty: Easy\n", 988 | "\n", 989 | "Expand the cell below to get the full solution. Study the solution and ask questions." 990 | ] 991 | }, 992 | { 993 | "cell_type": "code", 994 | "execution_count": null, 995 | "id": "dcf0e2ca-e3ea-4dd9-be27-a37fd852b47a", 996 | "metadata": { 997 | "jupyter": { 998 | "source_hidden": true 999 | }, 1000 | "tags": [] 1001 | }, 1002 | "outputs": [], 1003 | "source": [ 1004 | "%%time\n", 1005 | "from collections import deque\n", 1006 | "from dask.distributed import as_completed\n", 1007 | "\n", 1008 | "urls = deque()\n", 1009 | "urls.append(\"https://stackoverflow.com/questions/tagged/jupyter\") # seed with a single page\n", 1010 | "\n", 1011 | "all_tags = []\n", 1012 | "titles = []\n", 1013 | "url_futures = as_completed()\n", 1014 | "seen = set()\n", 1015 | "i = 0\n", 1016 | "\n", 1017 | "while urls or not url_futures.is_empty() and i < 1000:\n", 1018 | " if not urls:\n", 1019 | " future = url_futures.next()\n", 1020 | " new_urls = future.result()\n", 1021 | " urls.extend(new_urls)\n", 1022 | " continue\n", 1023 | " \n", 1024 | " url = urls.popleft()\n", 1025 | " \n", 1026 | " if url in seen:\n", 1027 | " continue\n", 1028 | " else:\n", 1029 | " seen.add(url)\n", 1030 | " \n", 1031 | " print(\".\", end=\"\")\n", 1032 | " i += 1\n", 1033 | "\n", 1034 | " page = client.submit(download, url, delay=0.25)\n", 1035 | " tags = client.submit(scrape_tags, page)\n", 1036 | " title = client.submit(scrape_title, page)\n", 1037 | "\n", 1038 | " all_tags.append(tags)\n", 1039 | " titles.append(title)\n", 1040 | " \n", 1041 | " new_urls = client.submit(scrape_links, page, base_url=\"https://stackoverflow.com\")\n", 1042 | " url_futures.add(new_urls)" 1043 | ] 1044 | }, 1045 | { 1046 | "cell_type": "markdown", 1047 | "id": "6a3330ea-5354-4f13-a256-5c59892aa2b2", 1048 | "metadata": {}, 1049 | "source": [ 1050 | "### Analyze results\n", 1051 | "\n", 1052 | "At this point you likely have lists `titles` and `all_tags` that are lists of futures. Let's gather them and analyze results." 1053 | ] 1054 | }, 1055 | { 1056 | "cell_type": "code", 1057 | "execution_count": null, 1058 | "id": "11ec75ee-9dc4-4d2b-a251-b21a88122934", 1059 | "metadata": { 1060 | "tags": [] 1061 | }, 1062 | "outputs": [], 1063 | "source": [ 1064 | "titles = client.gather(titles)\n", 1065 | "titles[:20]" 1066 | ] 1067 | }, 1068 | { 1069 | "cell_type": "code", 1070 | "execution_count": null, 1071 | "id": "399bec76-291b-4a82-8c35-3bbca648279e", 1072 | "metadata": {}, 1073 | "outputs": [], 1074 | "source": [ 1075 | "all_tags = client.gather(all_tags)" 1076 | ] 1077 | }, 1078 | { 1079 | "cell_type": "code", 1080 | "execution_count": null, 1081 | "id": "41e5d085-cd39-4f6e-b82b-5a9913d4bc44", 1082 | "metadata": {}, 1083 | "outputs": [], 1084 | "source": [ 1085 | "import collections\n", 1086 | "\n", 1087 | "tag_counter = collections.defaultdict(int)\n", 1088 | "\n", 1089 | "for tags in all_tags:\n", 1090 | " for tag in tags:\n", 1091 | " tag_counter[tag] += 1\n", 1092 | " \n", 1093 | "sorted(tag_counter.items(), key=lambda kv: kv[1], reverse=True)[:20]" 1094 | ] 1095 | }, 1096 | { 1097 | "cell_type": "markdown", 1098 | "id": "e329af0b-bf41-43b3-9163-92d58386c8d4", 1099 | "metadata": {}, 1100 | "source": [ 1101 | "## Clean up" 1102 | ] 1103 | }, 1104 | { 1105 | "cell_type": "code", 1106 | "execution_count": null, 1107 | "id": "b0d37a84-97ee-4969-8846-876fe43e3455", 1108 | "metadata": {}, 1109 | "outputs": [], 1110 | "source": [ 1111 | "cluster.shutdown()\n", 1112 | "client.close()" 1113 | ] 1114 | }, 1115 | { 1116 | "cell_type": "markdown", 1117 | "id": "62a7a6ef-b94b-46f8-af23-1a7ef27725f4", 1118 | "metadata": {}, 1119 | "source": [ 1120 | "### Useful links\n", 1121 | "\n", 1122 | "- https://tutorial.dask.org/05_futures.html\n", 1123 | "- [Futures documentation](https://docs.dask.org/en/latest/futures.html)\n", 1124 | "- [Futures screencast](https://www.youtube.com/watch?v=07EiCpdhtDE)\n", 1125 | "- [Futures examples](https://examples.dask.org/futures.html)\n", 1126 | "\n", 1127 | "### More Dask Tutorials\n", 1128 | "\n", 1129 | "Coiled also runs regular Dask tutorials. See [coiled.io/tutorials](https://www.coiled.io/tutorials) for more information. \n" 1130 | ] 1131 | } 1132 | ], 1133 | "metadata": { 1134 | "kernelspec": { 1135 | "display_name": "Python 3 (ipykernel)", 1136 | "language": "python", 1137 | "name": "python3" 1138 | }, 1139 | "language_info": { 1140 | "codemirror_mode": { 1141 | "name": "ipython", 1142 | "version": 3 1143 | }, 1144 | "file_extension": ".py", 1145 | "mimetype": "text/x-python", 1146 | "name": "python", 1147 | "nbconvert_exporter": "python", 1148 | "pygments_lexer": "ipython3", 1149 | "version": "3.10.0" 1150 | } 1151 | }, 1152 | "nbformat": 4, 1153 | "nbformat_minor": 5 1154 | } 1155 | -------------------------------------------------------------------------------- /2-Dataframes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "f8eafed2-77a1-4691-8e8b-aeb1187ce8f5", 6 | "metadata": { 7 | "tags": [] 8 | }, 9 | "source": [ 10 | "\"Dask\n", 14 | "\n", 15 | "\n", 16 | "Dask DataFrames\n", 17 | "===============\n", 18 | "\n", 19 | "Dask dataframes are like pandas dataframes, just bigger.\n", 20 | "\n", 21 | "\"Dask\n", 25 | "\n", 26 | "\n", 27 | "\n", 28 | "API-wise they're mostly the same, except that when you want an answer, add `.compute()` to the end.\n", 29 | "\n", 30 | "```python\n", 31 | "# Pandas\n", 32 | "df.groupby(\"name\").value.mean()\n", 33 | "\n", 34 | "# Dask DataFrame\n", 35 | "df.groupby(\"name\").value.mean().compute()\n", 36 | "```\n", 37 | "\n", 38 | "This brings the result back to your local machine, so it had better be small!\n", 39 | "\n", 40 | "```python\n", 41 | "df.compute() # this would be unwise\n", 42 | "```\n" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "id": "6ef10c79-b17d-4612-b808-ba26830d802f", 48 | "metadata": {}, 49 | "source": [ 50 | "## Ask for machines" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": null, 56 | "id": "9a9e6076-c8b3-4282-90a4-0fe3ab49440d", 57 | "metadata": { 58 | "tags": [] 59 | }, 60 | "outputs": [], 61 | "source": [ 62 | "import coiled\n", 63 | "\n", 64 | "cluster = coiled.Cluster(\n", 65 | " n_workers=20,\n", 66 | " region=\"us-east-2\", # start workers close to data to minimize costs\n", 67 | " account=\"dask-tutorials\",\n", 68 | ")\n", 69 | "\n", 70 | "client = cluster.get_client()" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "id": "1491663a-b4f5-46d9-9fb4-fc1f5a58421d", 76 | "metadata": {}, 77 | "source": [ 78 | "## Ingest Uber/Lyft Data\n", 79 | "\n", 80 | "\n", 81 | "The NYC Taxi dataset is a timeless classic. \n", 82 | "\n", 83 | "Interestingly there is a new variant. The NYC Taxi and Livery Commission requires data from all ride-share services in the city of New York. This includes private limosine services, van services, and a new category \"High Volume For Hire Vehicle\" services, those that dispatch 10,000 rides per day or more. This is a special category defined for Uber and Lyft. " 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "id": "33b598a4-fe0a-43c5-8007-0e955ac193f9", 90 | "metadata": {}, 91 | "outputs": [], 92 | "source": [ 93 | "import dask\n", 94 | "import pandas\n", 95 | "import dask.dataframe as dd\n", 96 | "import pandas as pd\n", 97 | "\n", 98 | "dask.config.set({\"dataframe.convert-string\": True}) # use PyArrow strings by default\n", 99 | "\n", 100 | "# df = pd.read_parquet( # this would work if we had enough memory\n", 101 | "df = dd.read_parquet(\n", 102 | " \"s3://coiled-datasets/uber-lyft-tlc/\",\n", 103 | " storage_options={\"anon\": True},\n", 104 | ")\n", 105 | "df.head()" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": null, 111 | "id": "70789360-efcd-40a0-bd28-24cb33d8dbdf", 112 | "metadata": { 113 | "tags": [] 114 | }, 115 | "outputs": [], 116 | "source": [ 117 | "df = df.persist()" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "id": "f9d012d8-6055-4cdc-a37e-d6a01b36c7db", 123 | "metadata": {}, 124 | "source": [ 125 | "Play time\n", 126 | "---------\n", 127 | "\n", 128 | "We start by playing around. We assume that you understand Pandas syntax. Please use it to compute the following quantities:" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": null, 134 | "id": "95a96932-2109-447c-9eb3-0d235de5e973", 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [ 138 | "df.columns" 139 | ] 140 | }, 141 | { 142 | "cell_type": "markdown", 143 | "id": "7042c351-c813-4a7e-a923-1fc45b908d8c", 144 | "metadata": {}, 145 | "source": [ 146 | "How much did New Yorkers pay Uber/Lyft? Sum the `base_passenger_fare` column." 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "id": "62a36191-d619-4b6f-b923-c0d185611aa3", 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "id": "d7c57df5-fd73-4d6e-847c-c7747041bc5a", 160 | "metadata": {}, 161 | "source": [ 162 | "How much did Uber/Lyft pay drivers?" 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": null, 168 | "id": "9d9a86ed-e286-48d2-8e54-52c421dc97c7", 169 | "metadata": {}, 170 | "outputs": [], 171 | "source": [] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "id": "25a05095-9a6e-44bf-bd38-dfafb386e565", 176 | "metadata": {}, 177 | "source": [ 178 | "Were there ever cases when Uber/Lyft paid drivers more than they made? How often did this occur?" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "id": "3fc3c20c-6318-48cc-8900-65a8146fd927", 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [] 188 | }, 189 | { 190 | "cell_type": "markdown", 191 | "id": "eba147d9-bea1-4073-8521-fd1329b71867", 192 | "metadata": {}, 193 | "source": [ 194 | "What fraction of rides had a non-zero tip?" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": null, 200 | "id": "c893ca7b-94a7-4c2d-8c8e-04926c83864c", 201 | "metadata": {}, 202 | "outputs": [], 203 | "source": [] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "id": "10f285be-6839-4866-9535-43adbcc965d0", 208 | "metadata": {}, 209 | "source": [ 210 | "## Broken down by carrier\n", 211 | "\n", 212 | "If we look at the frequencies of values in the `hvfhs_licence_num` column we can identify rides as Uber/Lyft or other less common carriers." 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": null, 218 | "id": "b71729eb-f841-433a-b020-0f2b1c425355", 219 | "metadata": {}, 220 | "outputs": [], 221 | "source": [ 222 | "df.hvfhs_license_num.value_counts().compute()" 223 | ] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "id": "d3f6e586-c870-4df4-9d5f-3539f1e2881a", 228 | "metadata": {}, 229 | "source": [ 230 | "Probably HV0003 is Uber, and HV0005 is Lyft." 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": null, 236 | "id": "d19855fb-8851-4d73-b418-43673f200b96", 237 | "metadata": {}, 238 | "outputs": [], 239 | "source": [] 240 | }, 241 | { 242 | "cell_type": "markdown", 243 | "id": "ba4191f1-6758-43dc-a631-e03fcd7755ca", 244 | "metadata": {}, 245 | "source": [ 246 | "How do the questions above break down by carrier?" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": null, 252 | "id": "74cb092c-11ea-40ef-8bcb-127b540681f3", 253 | "metadata": {}, 254 | "outputs": [], 255 | "source": [] 256 | } 257 | ], 258 | "metadata": { 259 | "kernelspec": { 260 | "display_name": "Python 3 (ipykernel)", 261 | "language": "python", 262 | "name": "python3" 263 | }, 264 | "language_info": { 265 | "codemirror_mode": { 266 | "name": "ipython", 267 | "version": 3 268 | }, 269 | "file_extension": ".py", 270 | "mimetype": "text/x-python", 271 | "name": "python", 272 | "nbconvert_exporter": "python", 273 | "pygments_lexer": "ipython3", 274 | "version": "3.10.0" 275 | } 276 | }, 277 | "nbformat": 4, 278 | "nbformat_minor": 5 279 | } 280 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Dask Tutorial 2 | 3 | In this tutorial you will learn the basics of Dask, specifically the following: 4 | 5 | 1. How to parallelize simple for-loop code with [Dask Futures](https://docs.dask.org/en/stable/futures.html) 6 | 2. How to scale up Pandas code with [Dask Dataframes](https://docs.dask.org/en/stable/dataframes.html) 7 | 8 | Additionally you will work on real large scale data using a cluster of machines on the cloud 9 | 10 | ## Set up 11 | 12 | 1. **Clone this repository** 13 | 14 | In your terminal: 15 | 16 | ``` 17 | git clone https://github.com/mrocklin/dask-tutorial 18 | cd dask-tutorial 19 | ``` 20 | 21 | Alternatively, you can download the zip file of the repository at the top of the main page of the repository. This is a good option if you don't have experience with git. 22 | 23 | 2. **Create Conda Environment** 24 | 25 | In your terminal navigate to the directory where you have cloned/downloaded the `dask-tutorial` repository and install the required packages: 26 | 27 | ``` 28 | conda env create -f binder/environment.yml 29 | ``` 30 | 31 | This will create a new environment called `dask-tutorial`. To activate the environment do: 32 | 33 | ``` 34 | conda activate dask-tutorial 35 | ``` 36 | 37 | Alternatively, you can run `pip install -r requirements.txt`. 38 | This may or may not work as well. 39 | We recommend doing this from a fresh Python environment (this will make 40 | synchronizing with your cluster easier). 41 | 42 | 3. **Establish Coiled Access** 43 | 44 | This tutorial will use Dask clusters on the cloud. We will get these 45 | clusters using a SaaS product, Coiled. You can either ... 46 | 47 | 1. Sign up (it's free and there's no commitment) as follows: 48 | 49 | ``` 50 | coiled login 51 | ``` 52 | 53 | You'll be asked to authenticate with GitHub to make an account. Don't 54 | worry about connecting to your cloud resources. We'll add you to the 55 | `dask-tutorials` team, which is connected to an AWS account of ours. 56 | 57 | To get this access, ask to be added in the #dask-tutorial channel. 58 | You'll also want to set your default account to `dask-tutorials`: 59 | 60 | ``` 61 | coiled config set account dask-tutorials 62 | ``` 63 | 64 | Alternatively, you can also ... 65 | 66 | 2. Use a short-lived auth token 67 | 68 | ``` 69 | coiled login --token 65924ef194cc4b658ff37c1c11caa357-2ad71e4ceeafd5a771f553306cff95eb9624ee2d --account dask-tutorials 70 | ``` 71 | 72 | This should just work, but will expire in a few days and you won't be 73 | able to access the web view. 74 | 75 | 4. **Open Jupyter Lab** 76 | 77 | Once your environment has been activated and you are in the `dask-tutorial` repository, start Jupyter Lab: 78 | 79 | ``` 80 | jupyter lab 81 | ``` 82 | 83 | You will see a notebooks directory, click on there and you will be ready to go. 84 | 85 | *We recommend Jupyter Lab due to the [Dask Jupyter extension](https://github.com/dask/dask-labextension).* 86 | 87 | ### Run on a Coiled notebook 88 | 89 | 1. **Setup virtual environment** 90 | ``` 91 | conda create -n dask-tutorial python=3.10 coiled jupyter 92 | conda activate dask-tutorial 93 | ``` 94 | 95 | 2. **Establish Coiled Access** 96 | 1. Sign up (it's free and there's no commitment) as follows: 97 | 98 | ``` 99 | coiled login 100 | ``` 101 | 102 | You'll be asked to authenticate with GitHub to make an account. Don't 103 | worry about connecting to your cloud resources. We'll add you to the 104 | `dask-tutorials` team, which is connected to an AWS account of ours. 105 | 106 | To get this access, ask to be added in the #dask-tutorial channel. 107 | You'll also want to set your default account to `dask-tutorials`: 108 | 109 | ``` 110 | coiled config set account dask-tutorials 111 | ``` 112 | 113 | Alternatively, you can also ... 114 | 115 | 2. Use a short-lived auth token 116 | 117 | ``` 118 | coiled login --token 65924ef194cc4b658ff37c1c11caa357-2ad71e4ceeafd5a771f553306cff95eb9624ee2d --account dask-tutorials 119 | ``` 120 | 121 | This should just work, but will expire in a few days and you won't be 122 | able to access the web view. 123 | 124 | 3. **Start Coiled notebook** 125 | ``` 126 | coiled notebook up --software jupytercon-notebook 127 | ``` 128 | 129 | **Note:** Don't forget to shut down your notebook after you're done! 130 | 131 | ### Run on mybinder.org 132 | 133 | The website [mybinder.org](https://mybinder.org) serves pre-configured Jupyter notebooks for 134 | free that you can also use. Here is the link → [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/mrocklin/dask-tutorial/HEAD). 135 | 136 | However, mybinder.org has tragically lost some of their funding recently, and 137 | so availability is not what it once was. We recommend running locally if 138 | possible. 139 | -------------------------------------------------------------------------------- /binder/environment.yml: -------------------------------------------------------------------------------- 1 | name: dask-tutorial 2 | channels: 3 | - conda-forge 4 | dependencies: 5 | - python==3.10 6 | - dask 7 | - coiled 8 | - pyarrow 9 | - ipykernel 10 | - dask-labextension 11 | - jupyterlab 12 | - s3fs 13 | -------------------------------------------------------------------------------- /binder/jupyterlab-workspace.json: -------------------------------------------------------------------------------- 1 | { 2 | "data": { 3 | "file-browser-filebrowser:cwd": { 4 | "path": "" 5 | }, 6 | "dask-dashboard-launcher": { 7 | "url": "DASK_DASHBOARD_URL" 8 | } 9 | }, 10 | "metadata": { 11 | "id": "/lab" 12 | } 13 | } -------------------------------------------------------------------------------- /binder/start: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Replace DASK_DASHBOARD_URL with the proxy location 4 | sed -i -e "s|DASK_DASHBOARD_URL|${JUPYTERHUB_BASE_URL}user/${JUPYTERHUB_USER}/proxy/8787|g" binder/jupyterlab-workspace.json 5 | export DASK_DISTRIBUTED__DASHBOARD__LINK="${JUPYTERHUB_SERVICE_PREFIX}proxy/{port}/status" 6 | 7 | 8 | # Import the workspace 9 | jupyter lab workspaces import binder/jupyterlab-workspace.json 10 | 11 | # Install Coiled token 12 | coiled login --token 65924ef194cc4b658ff37c1c11caa357-2ad71e4ceeafd5a771f553306cff95eb9624ee2d --account dask-tutorials 13 | 14 | exec "$@" 15 | -------------------------------------------------------------------------------- /images/nyc-taxi-scatter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mrocklin/dask-tutorial/98eefba7373e4828535b09e0ad6aa02a0456b2f5/images/nyc-taxi-scatter.png -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | dask[complete] 2 | pyarrow 3 | coiled 4 | jupyterlab 5 | dask-labextension==6.0 6 | ipykernel 7 | s3fs 8 | --------------------------------------------------------------------------------