Fixed bugs in notebook names and references to them.

Dean Wampler · Dean Wampler · commit 4226a397e274 · 2020-08-03T08:59:59.000-07:00
diff --git a/Overview.ipynb b/Overview.ipynb
@@ -135,7 +135,7 @@
     "\n",
     "|    | Lesson (Notebook)                                                          | Description                               |\n",
     "| :- | :------------------------------------------------------------------------- | :---------------------------------------- |\n",
-    "| 00 | [Overview](ray-crash-course/00-Overview-Ray-Crash-Course.ipynb)            | A _table of contents_ for this tutorial.  |\n",
+    "| 00 | [Overview](ray-crash-course/00-Ray-Crash-Course-Overview.ipynb)            | A _table of contents_ for this tutorial.  |\n",
     "| 01 | [Ray Tasks](ray-crash-course/01-Ray-Tasks.ipynb)                           | Understanding how Ray converts normal Python functions into distributed _stateless tasks_. |\n",
     "| 02 | [Ray Actors](ray-crash-course/02-Ray-Actors.ipynb)                         | Understanding how Ray converts normal Python classes into distributed, _stateful actors_.  |\n",
     "| 03 | [Why Ray?](ray-crash-course/03-Why-Ray.ipynb)                              | Now that you've seen Ray in action, take a step back and explore the origin and motivations for Ray, and Ray's growing ecosystem of libraries and tools.   |\n",
@@ -167,7 +167,7 @@
     "\n",
     "|    | Lesson (Notebook)                                         | Description                               |\n",
     "| :- | :-------------------------------------------------------- | :---------------------------------------- |\n",
-    "| 00 | [Overview](advanced-ray/00-Overview-Advanced-Ray.ipynb)   | A _table of contents_ for this tutorial.  |\n",
+    "| 00 | [Overview](advanced-ray/00-Advanced-Ray-Overview.ipynb)   | A _table of contents_ for this tutorial.  |\n",
     "| 01 | [Ray Tasks Revisited](advanced-ray/01-Ray-Tasks-Revisited.ipynb) | More exploration of `ray.wait()` usage patterns, task dependencies and their management, and task profiling techniques. |\n",
     "| 02 | [Ray Actors Revisited](advanced-ray/02-Ray-Actors-Revisited.ipynb) | A more in-depth look at actor characteristics and profiling actor performance using the _Ray Dashboard_. |\n",
     "| 03 | [Ray Internals](advanced-ray/03-Ray-Internals.ipynb) | Explores the architecture of Ray, task scheduling, the Object Store, etc. |\n",
diff --git a/README.md b/README.md
@@ -148,9 +148,9 @@ Here is a recommended reading list, based on your interests:
 
 | You Are... | Best Tutorials |
 | :--------- | :------------- |
-| A developer who is new to Ray | First, [_Ray Crash Course_](ray-crash-course/00-Overview-Ray-Crash-Course.ipynb), then [_Advanced Ray_](advanced-ray/00-Overview-Advanced-Ray.ipynb) |
-| A developer who is experienced with Ray | [_Advanced Ray_](advanced-ray/00-Overview-Advanced-Ray.ipynb) (_alpha_ release) |
-| A developer or data scientist interested in Reinforcement Learning | [_Ray RLlib_](rllib/00-Overview-Ray-RLlib.ipynb) |
+| A developer who is new to Ray | First, [_Ray Crash Course_](ray-crash-course/00-Ray-Crash-Course-Overview.ipynb), then [_Advanced Ray_](advanced-ray/00-Advanced-Ray-Overview.ipynb) |
+| A developer who is experienced with Ray | [_Advanced Ray_](advanced-ray/00-Advanced-Ray-Overview.ipynb) (_alpha_ release) |
+| A developer or data scientist interested in Reinforcement Learning | [_Ray RLlib_](rllib/00-Ray-RLlib-Overview.ipynb) |
 | A developer or data scientist interested in Hyperparameter Tuning  | _Ray Tune_ |
 | A developer or data scientist interested in accelerated model training with PyTorch  |See the _Ray SGD_ lesson in the _Ray Tune_ tutorial |
 | A developer or data scientist interested in model serving | _Ray Serve_ |
diff --git a/advanced-ray/00-Advanced-Ray-Overview.ipynb b/advanced-ray/00-Advanced-Ray-Overview.ipynb
@@ -33,7 +33,7 @@
     "\n",
     "| #  | Lesson (Notebook)                                         | Description                               |\n",
     "| :- | :-------------------------------------------------------- | :---------------------------------------- |\n",
-    "| 00 | [Overview](00-Overview-Advanced-Ray.ipynb)   | A _table of contents_ for this tutorial.  |\n",
+    "| 00 | [Overview](00-Advanced-Ray-Overview.ipynb)   | A _table of contents_ for this tutorial.  |\n",
     "| 01 | [Ray Tasks Revisited](01-Ray-Tasks-Revisited.ipynb) | More exploration of `ray.wait()` usage patterns, task dependencies and their management, and task profiling techniques. |\n",
     "| 02 | [Ray Actors Revisited](02-Ray-Actors-Revisited.ipynb) | A more in-depth look at actor characteristics and profiling actor performance using the _Ray Dashboard_. |\n",
     "| 03 | [Ray Internals](03-Ray-Internals.ipynb) | Explores the architecture of Ray, task scheduling, the Object Store, etc. |\n",
diff --git a/advanced-ray/02-Ray-Actors-Revisited.ipynb b/advanced-ray/02-Ray-Actors-Revisited.ipynb
@@ -227,7 +227,7 @@
     "\n",
     "Now we'll investigate how to profile performance of Ray actors using the Ray Dashboard ([documentation](https://ray.readthedocs.io/en/latest/ray-dashboard.html#ray-dashboard)). \n",
     "\n",
-    "First, let's redefine the _Conway's Game of Life_ code we used in [02: Ray Actors](../ray-crash-course/02-Ray-Actors.ipynb) in the [Ray Crash Course](../ray-crash-course/00-Overview-Ray-Crash-Course.ipynb) tutorial. We've simplified a few details and pulled the definitions of `RayConwaysRules` and `State` into `RayGame` for easier distribution of everything over a cluster.\n",
+    "First, let's redefine the _Conway's Game of Life_ code we used in [02: Ray Actors](../ray-crash-course/02-Ray-Actors.ipynb) in the [Ray Crash Course](../ray-crash-course/00-Ray-Crash-Course-Overview.ipynb) tutorial. We've simplified a few details and pulled the definitions of `RayConwaysRules` and `State` into `RayGame` for easier distribution of everything over a cluster.\n",
     "\n",
     "This same code will be used in the exercise below. You can also find it the file [game_of_life_2.py](game_of_life_2.py)."
    ]
diff --git a/ray-cluster-launcher/00-Ray-Cluster-Launcher-Overview.ipynb b/ray-cluster-launcher/00-Ray-Cluster-Launcher-Overview.ipynb
diff --git a/ray-crash-course/00-Ray-Crash-Course-Overview.ipynb b/ray-crash-course/00-Ray-Crash-Course-Overview.ipynb
@@ -56,7 +56,7 @@
     "\n",
     "| #  | Lesson (Notebook)                                         | Description                               |\n",
     "| :- | :-------------------------------------------------------- | :---------------------------------------- |\n",
-    "| 00 | [Overview](00-Overview-Ray-Crash-Course.ipynb)            | A _table of contents_ for this tutorial.  |\n",
+    "| 00 | [Overview](00-Ray-Crash-Course-Overview.ipynb)            | A _table of contents_ for this tutorial.  |\n",
     "| 01 | [Ray Tasks](01-Ray-Tasks.ipynb)                           | Understanding how Ray converts normal Python functions into distributed _stateless tasks_. |\n",
     "| 02 | [Ray Actors](02-Ray-Actors.ipynb)                         | Understanding how Ray converts normal Python classes into distributed, _stateful actors_.  |\n",
     "| 03 | [Why Ray?](03-Why-Ray.ipynb)                              | Now that you've seen Ray in action, take a step back and explore the origin and motivations for Ray, and Ray's growing ecosystem of libraries and tools.  |\n",
diff --git a/ray-crash-course/01-Ray-Tasks.ipynb b/ray-crash-course/01-Ray-Tasks.ipynb
@@ -608,7 +608,7 @@
    "source": [
     "## ray.get() vs. ray.wait()\n",
     "\n",
-    "Calling `ray.get(ids)` blocks until all the tasks have completed that correspond to the input `ids`. That has been fine for this tutorial so far, but what if you're waiting for a number of tasks, where some will finish more quickly than others? What if you would like to process the completed results as they become available, even while other tasks are still running? That's where `ray.wait()` is recommended. Here we'll provide a brief example. For more details, see the [Ray Core - A Deeper Dive](../ray-core/00-Overview.ipynb) tutorial."
+    "Calling `ray.get(ids)` blocks until all the tasks have completed that correspond to the input `ids`. That has been fine for this tutorial so far, but what if you're waiting for a number of tasks, where some will finish more quickly than others? What if you would like to process the completed results as they become available, even while other tasks are still running? That's where `ray.wait()` is recommended. Here we'll provide a brief example. For more details, see the Advanced Ray, [Ray Tasks Revisited](../advanced-ray/01-Ray-Tasks-Revisited.ipynb) lesson."
    ]
   },
   {
diff --git a/ray-crash-course/02-Ray-Actors.ipynb b/ray-crash-course/02-Ray-Actors.ipynb
@@ -742,7 +742,7 @@
     "* Once a _task_ finishes, it is removed from the worker that executed it, while an actor is _pinned_ to the worker until all Python references to it in the driver program are out of scope. That is, the usual garbage collection mechanism in Python determines when an actor is no longer needed and is removed from a worker. The reason the actor must remain in memory is because it holds state that might be needed, whereas tasks are stateless.\n",
     "* Currently, each actor instance uses tens of MB of memory overhead. Hence, just as you should avoid having too many fine-grained tasks, you should avoid too many actor instances. (Reducing the overhead per actor is an ongoing improvement project.)\n",
     "\n",
-    "We explore actor scheduling and lifecycles in much greater depth in lesson [03: Ray Internals](03-Ray-Internals.ipynb) in the [Advanced Ray](../advanced-ray/00-Overview-Advanced-Ray.ipynb) tutorial."
+    "We explore actor scheduling and lifecycles in much greater depth in lesson [03: Ray Internals](03-Ray-Internals.ipynb) in the [Advanced Ray](../advanced-ray/00-Advanced-Ray-Overview.ipynb) tutorial."
    ]
   },
   {

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@`
`227`	`227`	`"\n",`
`228`	`228`	`"Now we'll investigate how to profile performance of Ray actors using the Ray Dashboard ([documentation](https://ray.readthedocs.io/en/latest/ray-dashboard.html#ray-dashboard)). \n",`
`229`	`229`	`"\n",`
`230`		- "First, let's redefine the _Conway's Game of Life_ code we used in [02: Ray Actors](../ray-crash-course/02-Ray-Actors.ipynb) in the [Ray Crash Course](../ray-crash-course/00-Overview-Ray-Crash-Course.ipynb) tutorial. We've simplified a few details and pulled the definitions of `RayConwaysRules` and `State` into `RayGame` for easier distribution of everything over a cluster.\n",
	`230`	+ "First, let's redefine the _Conway's Game of Life_ code we used in [02: Ray Actors](../ray-crash-course/02-Ray-Actors.ipynb) in the [Ray Crash Course](../ray-crash-course/00-Ray-Crash-Course-Overview.ipynb) tutorial. We've simplified a few details and pulled the definitions of `RayConwaysRules` and `State` into `RayGame` for easier distribution of everything over a cluster.\n",
`231`	`231`	`"\n",`
`232`	`232`	`"This same code will be used in the exercise below. You can also find it the file [game_of_life_2.py](game_of_life_2.py)."`
`233`	`233`	`]`
Original file line number	Diff line number	Diff line change
`@@ -608,7 +608,7 @@`
`608`	`608`	`"source": [`
`609`	`609`	`"## ray.get() vs. ray.wait()\n",`
`610`	`610`	`"\n",`
`611`		- "Calling `ray.get(ids)` blocks until all the tasks have completed that correspond to the input `ids`. That has been fine for this tutorial so far, but what if you're waiting for a number of tasks, where some will finish more quickly than others? What if you would like to process the completed results as they become available, even while other tasks are still running? That's where `ray.wait()` is recommended. Here we'll provide a brief example. For more details, see the [Ray Core - A Deeper Dive](../ray-core/00-Overview.ipynb) tutorial."
	`611`	+ "Calling `ray.get(ids)` blocks until all the tasks have completed that correspond to the input `ids`. That has been fine for this tutorial so far, but what if you're waiting for a number of tasks, where some will finish more quickly than others? What if you would like to process the completed results as they become available, even while other tasks are still running? That's where `ray.wait()` is recommended. Here we'll provide a brief example. For more details, see the Advanced Ray, [Ray Tasks Revisited](../advanced-ray/01-Ray-Tasks-Revisited.ipynb) lesson."
`612`	`612`	`]`
`613`	`613`	`},`
`614`	`614`	`{`
Original file line number	Diff line number	Diff line change
`@@ -742,7 +742,7 @@`
`742`	`742`	`"* Once a _task_ finishes, it is removed from the worker that executed it, while an actor is _pinned_ to the worker until all Python references to it in the driver program are out of scope. That is, the usual garbage collection mechanism in Python determines when an actor is no longer needed and is removed from a worker. The reason the actor must remain in memory is because it holds state that might be needed, whereas tasks are stateless.\n",`
`743`	`743`	`"* Currently, each actor instance uses tens of MB of memory overhead. Hence, just as you should avoid having too many fine-grained tasks, you should avoid too many actor instances. (Reducing the overhead per actor is an ongoing improvement project.)\n",`
`744`	`744`	`"\n",`
`745`		`- "We explore actor scheduling and lifecycles in much greater depth in lesson [03: Ray Internals](03-Ray-Internals.ipynb) in the [Advanced Ray](../advanced-ray/00-Overview-Advanced-Ray.ipynb) tutorial."`
	`745`	`+ "We explore actor scheduling and lifecycles in much greater depth in lesson [03: Ray Internals](03-Ray-Internals.ipynb) in the [Advanced Ray](../advanced-ray/00-Advanced-Ray-Overview.ipynb) tutorial."`
`746`	`746`	`]`
`747`	`747`	`},`
`748`	`748`	`{`