View source on GitHub |
Performs a union on underlying ClusterResolvers.
Inherits From: ClusterResolver
tf.distribute.cluster_resolver.UnionResolver(
*args, **kwargs
)
This class performs a union given two or more existing ClusterResolvers. It merges the underlying ClusterResolvers, and returns one unified ClusterSpec when cluster_spec is called. The details of the merge function is documented in the cluster_spec function.
For additional ClusterResolver properties such as task type, task index, rpc layer, environment, etc..., we will return the value from the first ClusterResolver in the union.
An example to combine two cluster resolvers:
cluster_0 = tf.train.ClusterSpec({"worker": ["worker0.example.com:2222",
"worker1.example.com:2222"]})
cluster_resolver_0 = SimpleClusterResolver(cluster, task_type="worker",
task_id=0,
rpc_layer="grpc")
cluster_1 = tf.train.ClusterSpec({"ps": ["ps0.example.com:2222",
"ps1.example.com:2222"]})
cluster_resolver_1 = SimpleClusterResolver(cluster, task_type="ps",
task_id=0,
rpc_layer="grpc")
# Its task type would be "worker".
cluster_resolver = UnionClusterResolver(cluster_resolver_0,
cluster_resolver_1)
An example to override the number of GPUs in a TFConfigClusterResolver instance:
tf_config = TFConfigClusterResolver()
gpu_override = SimpleClusterResolver(tf_config.cluster_spec(),
num_accelerators={"GPU": 1})
cluster_resolver = UnionResolver(gpu_override, tf_config)
Raises | |
---|---|
TypeError
|
If any argument is not a subclass of ClusterResolvers .
|
ValueError
|
If there are no arguments passed. |
Attributes | |
---|---|
environment
|
Returns the current environment which TensorFlow is running in.
There are two possible return values, "google" (when TensorFlow is running in a Google-internal environment) or an empty string (when TensorFlow is running elsewhere). If you are implementing a ClusterResolver that works in both the Google environment and the open-source world (for instance, a TPU ClusterResolver or similar), you will have to return the appropriate string depending on the environment, which you will have to detect. Otherwise, if you are implementing a ClusterResolver that will only work in open-source TensorFlow, you do not need to implement this property. |
rpc_layer
|
|
task_id
|
Returns the task id this ClusterResolver indicates.
In TensorFlow distributed environment, each job may have an applicable task id, which is the index of the instance within its task type. This is useful when user needs to run specific code according to task index. For example,
Returns For more information, please see
|
task_type
|
Returns the task type this ClusterResolver indicates.
In TensorFlow distributed environment, each job may have an applicable task type. Valid task types in TensorFlow include 'chief': a worker that is designated with more responsibility, 'worker': a regular worker for training/evaluation, 'ps': a parameter server, or 'evaluator': an evaluator that evaluates the checkpoints for metrics. See Multi-worker configuration for more information about 'chief' and 'worker' task type, which are most commonly used. Having access to such information is useful when user needs to run specific code according to task types. For example,
Returns For more information, please see
|
Methods
cluster_spec
cluster_spec()
Returns a union of all the ClusterSpecs from the ClusterResolvers.
Returns | |
---|---|
A ClusterSpec containing host information merged from all the underlying ClusterResolvers. |
Raises | |
---|---|
KeyError
|
If there are conflicting keys detected when merging two or more dictionaries, this exception is raised. |
If all underlying ClusterSpecs expose the set of workers as lists, we will concatenate the lists of workers, starting with the list of workers from the first ClusterResolver passed into the constructor.
If any of the ClusterSpecs expose the set of workers as a dict, we will
treat all the sets of workers as dicts (even if they are returned as lists)
and will only merge them into a dict if there is no conflicting keys. If
there is a conflicting key, we will raise a KeyError
.
master
master(
task_type=None, task_id=None, rpc_layer=None
)
Returns the master address to use when creating a session.
This usually returns the master from the first ClusterResolver passed in, but you can override this by specifying the task_type and task_id.
Args | |
---|---|
task_type
|
(Optional) The type of the TensorFlow task of the master. |
task_id
|
(Optional) The index of the TensorFlow task of the master. |
rpc_layer
|
(Optional) The RPC protocol for the given cluster. |
Returns | |
---|---|
The name or URL of the session master. |
num_accelerators
num_accelerators(
task_type=None, task_id=None, config_proto=None
)
Returns the number of accelerator cores per worker.
This returns the number of accelerator cores (such as GPUs and TPUs) available per worker.
Optionally, we allow callers to specify the task_type, and task_id, for if they want to target a specific TensorFlow task to query the number of accelerators. This is to support heterogenous environments, where the number of accelerators cores per host is different.
Args | |
---|---|
task_type
|
(Optional) The type of the TensorFlow task of the machine we want to query. |
task_id
|
(Optional) The index of the TensorFlow task of the machine we want to query. |
config_proto
|
(Optional) Configuration for starting a new session to query how many accelerator cores it has. |
Returns | |
---|---|
A map of accelerator types to number of cores. |