[Data] Remove ActorPoolStrategy from documentation #41948

c21 · 2023-12-15T06:19:47Z

Why are these changes needed?

This PR is to remove ActorPoolStrategy, and replace it with concurrency parameter in all documentations.

Related issue number

#40725

Checks

I've signed off every commit(by using the -s flag, i.e., git commit -s) in this PR.
I've run scripts/format.sh to lint the changes in this PR.
I've included any doc changes needed for https://docs.ray.io/en/master/.
- I've added any new APIs to the API Reference. For example, if I added a
  method in Tune, I've added it in doc/source/tune/api/ under the
  corresponding .rst file.
I've made sure the tests are passing. Note that there might be a few flaky tests, see the recent failures at https://flakey-tests.ray.io/
Testing Strategy
- Unit tests
- Release tests
- This PR is not tested :(

Signed-off-by: Cheng Su <[email protected]>

angelinalg

Some style nits. In the future, consider using Vale (go/vale) for automated linting. It will report most of the corrections I made, like:

avoid future tense
avoid using first person ("we")
avoid using "please"

angelinalg · 2023-12-15T19:52:16Z

doc/source/data/examples/batch_inference_object_detection.ipynb

@@ -919,7 +919,7 @@
 "source": [
 "Then we use the {meth}`map_batches <ray.data.Dataset.map_batches>` API to apply the model to the whole dataset. \n",
 "\n",
- "The first parameter of `map` and `map_batches` is the user-defined function (UDF), which can either be a function or a class. Function-based UDFs will run as short-running [Ray tasks](https://docs.ray.io/en/latest/ray-core/key-concepts.html#tasks), and class-based UDFs will run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/key-concepts.html#actors). For class-based UDFs, we use the `compute` argument to specify {class}`ActorPoolStrategy <ray.data.dataset_internal.compute.ActorPoolStrategy>` with the number of parallel actors. And the `batch_size` argument indicates the number of images in each batch.\n",
+ "The first parameter of `map` and `map_batches` is the user-defined function (UDF), which can either be a function or a class. Function-based UDFs will run as short-running [Ray tasks](https://docs.ray.io/en/latest/ray-core/key-concepts.html#tasks), and class-based UDFs will run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/key-concepts.html#actors). For class-based UDFs, we use the `concurrency` argument to specify the number of parallel actors. And the `batch_size` argument indicates the number of images in each batch.\n",


Suggested change

"The first parameter of `map` and `map_batches` is the user-defined function (UDF), which can either be a function or a class. Function-based UDFs will run as short-running [Ray tasks](https://docs.ray.io/en/latest/ray-core/key-concepts.html#tasks), and class-based UDFs will run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/key-concepts.html#actors). For class-based UDFs, we use the `concurrency` argument to specify the number of parallel actors. And the `batch_size` argument indicates the number of images in each batch.\n",

"The first parameter of `map` and `map_batches` is the user-defined function (UDF), which can either be a function or a class. Function-based UDFs run as short-running [Ray tasks](https://docs.ray.io/en/latest/ray-core/key-concepts.html#tasks), and class-based UDFs run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/key-concepts.html#actors). For class-based UDFs, use the `concurrency` argument to specify the number of parallel actors. The `batch_size` argument indicates the number of images in each batch.\n",

angelinalg · 2023-12-15T19:53:40Z

doc/source/data/examples/huggingface_vit_batch_prediction.ipynb

@@ -353,7 +353,7 @@
 "source": [
 "Then we use the {meth}`map_batches <ray.data.Dataset.map_batches>` API to apply the model to the whole dataset. \n",
 "\n",
- "The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/key-concepts.html#actors). For class-based UDFs, we use the `compute` argument to specify {class}`ActorPoolStrategy <ray.data.dataset_internal.compute.ActorPoolStrategy>` with the number of parallel actors. And the `batch_size` argument indicates the number of images in each batch.\n",
+ "The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/key-concepts.html#actors). For class-based UDFs, we use the `concurrency` argument to specify the number of parallel actors. And the `batch_size` argument indicates the number of images in each batch.\n",


Suggested change

"The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/key-concepts.html#actors). For class-based UDFs, we use the `concurrency` argument to specify the number of parallel actors. And the `batch_size` argument indicates the number of images in each batch.\n",

"The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Because this case uses a class, the UDF runs as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/key-concepts.html#actors). For class-based UDFs, use the `concurrency` argument to specify the number of parallel actors. The `batch_size` argument indicates the number of images in each batch.\n",

angelinalg · 2023-12-15T19:54:19Z

doc/source/data/examples/pytorch_resnet_batch_prediction.ipynb

@@ -439,7 +439,7 @@
 "source": [
 "Then we use the {meth}`~ray.data.Dataset.map_batches` API to apply the model to the whole dataset.\n",
 "\n",
- "The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](actor-guide). For class-based UDFs, we use the `compute` argument to specify {class}`~ray.data.ActorPoolStrategy` with the number of parallel actors.\n",
+ "The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](actor-guide). For class-based UDFs, we use the `concurrency` argument to specify the number of parallel actors.\n",


Suggested change

"The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](actor-guide). For class-based UDFs, we use the `concurrency` argument to specify the number of parallel actors.\n",

"The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Because this case uses a class, the UDF runs as long-running [Ray actors](actor-guide). For class-based UDFs, use the `concurrency` argument to specify the number of parallel actors.\n",

angelinalg · 2023-12-15T19:55:17Z

doc/source/templates/01_batch_inference/start.ipynb

@@ -439,7 +439,7 @@
 "source": [
 "Then we use the [`map_batches`](https://docs.ray.io/en/latest/data/api/doc/ray.data.Dataset.map_batches.html) API to apply the model to the whole dataset.\n",
 "\n",
- "The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/actors.html). For class-based UDFs, we use the `compute` argument to specify [`ActorPoolStrategy`](https://docs.ray.io/en/latest/data/api/doc/ray.data.ActorPoolStrategy.html) with the number of parallel actors.\n",
+ "The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/actors.html). For class-based UDFs, we use the `concurrency` argument to specify the number of parallel actors.\n",


Suggested change

"The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/actors.html). For class-based UDFs, we use the `concurrency` argument to specify the number of parallel actors.\n",

"The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Because this class uses a class, the UDF runs as long-running [Ray actors](https://docs.ray.io/en/latest/ray-core/actors.html). For class-based UDFs, use the `concurrency` argument to specify the number of parallel actors.\n",

angelinalg · 2023-12-15T19:55:48Z

python/ray/data/_internal/execution/interfaces/execution_options.py

@@ -103,7 +103,7 @@ class ExecutionOptions:
 operators under the streaming executor. The bulk executor always preserves
 order. Off by default.
 actor_locality_enabled: Whether to enable locality-aware task dispatch to
- actors (on by default). This applies to both ActorPoolStrategy map and
+ actors (on by default). This applies to both stateful map and


Suggested change

actors (on by default). This applies to both stateful map and

actors (on by default). This parameter applies to both stateful map and

angelinalg · 2023-12-15T19:56:05Z

python/ray/data/dataset.py

- compute: Either "tasks" (default) to use Ray Tasks or an
- :class:`~ray.data.ActorPoolStrategy` to use an autoscaling actor pool.
- This argument is deprecated. Please use ``concurrency`` argument instead.
+ compute: This argument is deprecated. Please use ``concurrency`` argument.


Suggested change

compute: This argument is deprecated. Please use ``concurrency`` argument.

compute: This argument is deprecated. Use ``concurrency`` argument.

justinvyu

Much easier!

…ns.py Co-authored-by: angelinalg <[email protected]> Signed-off-by: Cheng Su <[email protected]>

…on_options.py" This reverts commit 5ed4c8a.

Signed-off-by: Cheng Su <[email protected]>

pcmoritz · 2023-12-15T21:50:55Z

doc/source/data/batch_inference.rst

@@ -73,9 +73,9 @@ For how to configure batch inference, see :ref:`the configuration guide<batch_in

 # Use 2 parallel actors for inference. Each actor predicts on a
 # different partition of data.
- scale = ray.data.ActorPoolStrategy(size=2)
+ concurrency = 2


With the new API (which is much better) I don't think putting this on a separate line makes a lot of sense. Maybe inline it below and say Step 3: Map the Predictor over the dataset to get predictions. Use 2 parallel actors for inference. Each actor predicts on a different partition of data. as the comment?

yes, updated.

Signed-off-by: Cheng Su <[email protected]>

This PR is to remove `ActorPoolStrategy`, and replace it with `concurrency` parameter in all documentations. Signed-off-by: Cheng Su <[email protected]>

Remove ActorPoolStrategy from documentation

8fe7d66

Signed-off-by: Cheng Su <[email protected]>

c21 requested review from richardliaw, krfricke, xwjiang2010, amogkam, matthewdeng, Yard1, maxpumperla, justinvyu, woshiyyya, a team, ericl, scv119, scottjlee, bveeramani, raulchen, stephanie-wang, Zandew and sofianhnaide as code owners December 15, 2023 06:19

c21 added the release-blocker P0 Issue that blocks the release label Dec 15, 2023

This was referenced Dec 15, 2023

[WIP][Data] Get rid of ActorPoolStrategy from tests and docs #41649

Closed

[data] refine concepts in user-facing APIs #40725

Closed

c21 assigned raulchen and scottjlee Dec 15, 2023

scottjlee approved these changes Dec 15, 2023

View reviewed changes

angelinalg approved these changes Dec 15, 2023

View reviewed changes

justinvyu approved these changes Dec 15, 2023

View reviewed changes

c21 and others added 3 commits December 15, 2023 12:28

Update python/ray/data/_internal/execution/interfaces/execution_optio…

5ed4c8a

…ns.py Co-authored-by: angelinalg <[email protected]> Signed-off-by: Cheng Su <[email protected]>

Revert "Update python/ray/data/_internal/execution/interfaces/executi…

58bc380

…on_options.py" This reverts commit 5ed4c8a.

Address comments

bda7160

Signed-off-by: Cheng Su <[email protected]>

pcmoritz reviewed Dec 15, 2023

View reviewed changes

Address comments

adeee49

Signed-off-by: Cheng Su <[email protected]>

pcmoritz approved these changes Dec 15, 2023

View reviewed changes

c21 merged commit 4579860 into ray-project:master Dec 15, 2023
7 of 17 checks passed

c21 deleted the concurrency-doc branch December 15, 2023 23:29

c21 mentioned this pull request Dec 15, 2023

[2.9][Data] Remove ActorPoolStrategy from documentation #41963

Merged

8 tasks

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[Data] Remove ActorPoolStrategy from documentation #41948

[Data] Remove ActorPoolStrategy from documentation #41948

c21 commented Dec 15, 2023 •

edited

Loading

angelinalg left a comment

angelinalg Dec 15, 2023

c21 Dec 15, 2023

angelinalg Dec 15, 2023

c21 Dec 15, 2023

angelinalg Dec 15, 2023

c21 Dec 15, 2023

angelinalg Dec 15, 2023

c21 Dec 15, 2023

angelinalg Dec 15, 2023

c21 Dec 15, 2023

angelinalg Dec 15, 2023

c21 Dec 15, 2023

justinvyu left a comment

pcmoritz Dec 15, 2023

c21 Dec 15, 2023

	"The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Since we are using a class in this case, the UDF will run as long-running [Ray actors](actor-guide). For class-based UDFs, we use the `concurrency` argument to specify the number of parallel actors.\n",
	"The first parameter of `map_batches` is the user-defined function (UDF), which can either be a function or a class. Because this case uses a class, the UDF runs as long-running [Ray actors](actor-guide). For class-based UDFs, use the `concurrency` argument to specify the number of parallel actors.\n",

	actors (on by default). This applies to both stateful map and
	actors (on by default). This parameter applies to both stateful map and

	compute: This argument is deprecated. Please use ``concurrency`` argument.
	compute: This argument is deprecated. Use ``concurrency`` argument.

[Data] Remove ActorPoolStrategy from documentation #41948

[Data] Remove ActorPoolStrategy from documentation #41948

Conversation

c21 commented Dec 15, 2023 • edited Loading

Why are these changes needed?

Related issue number

Checks

angelinalg left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

justinvyu left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

c21 commented Dec 15, 2023 •

edited

Loading