o 2hS@sdZddlmZddlmZddlmZddlmZddlm Z ddl m Z ddl m Z dd l mZd d Zed d d gde d GdddZedGdddZedGdddZdS)z3A Python interface for creating TensorFlow servers.) cluster_pb2)device_filters_pb2)tensorflow_server_pb2)pywrap_tf_session)errors)compat) deprecation) tf_exportcCst}t|tjr0|||dur||_|dur||_|dur$||_|dur.|j||Szt|}Wn t yAt dw|durWt |j dkrS|j d}nt d|duro| |}t |dkrk|d}nt d|durud}tj||||d}|dur|j||S) aCreates a `tf.train.ServerDef` protocol buffer. Args: server_or_cluster_def: A `tf.train.ServerDef` or `tf.train.ClusterDef` protocol buffer, or a `tf.train.ClusterSpec` object, describing the server to be defined and/or the cluster of which it is a member. job_name: (Optional.) Specifies the name of the job of which the server is a member. Defaults to the value in `server_or_cluster_def`, if specified. task_index: (Optional.) Specifies the task index of the server in its job. Defaults to the value in `server_or_cluster_def`, if specified. Otherwise defaults to 0 if the server's job has only one task. protocol: (Optional.) Specifies the protocol to be used by the server. Acceptable values include `"grpc", "grpc+verbs"`. Defaults to the value in `server_or_cluster_def`, if specified. Otherwise defaults to `"grpc"`. config: (Options.) A `tf.compat.v1.ConfigProto` that specifies default configuration options for all sessions that run on this server. Returns: A `tf.train.ServerDef`. Raises: TypeError: If the arguments do not have the appropriate type. ValueError: If an argument is not specified and cannot be inferred. Nz^Could not convert `server_or_cluster_def` to a `tf.train.ServerDef` or `tf.train.ClusterSpec`.rz$Must specify an explicit `job_name`.z&Must specify an explicit `task_index`.grpc)clusterjob_name task_indexprotocol)r ServerDef isinstance MergeFromr rrdefault_session_config ClusterSpec TypeErrorlenjobs ValueError task_indicesas_cluster_def)server_or_cluster_defr rrconfig server_def cluster_specrr`/var/www/html/chatgem/venv/lib/python3.10/site-packages/tensorflow/python/training/server_lib.py_make_server_defsJ          r!zdistribute.Serverz train.Server)v1c@sbeZdZdZ     dddZddZdd Zd d Zed d Z eddZ e dddZ dS)ServeraAn in-process TensorFlow server, for use in distributed training. A `tf.distribute.Server` instance encapsulates a set of devices and a `tf.compat.v1.Session` target that can participate in distributed training. A server belongs to a cluster (specified by a `tf.train.ClusterSpec`), and corresponds to a particular task in a named job. The server can communicate with any other server in the same cluster. NTcCs8t||||||_t|j|_|r|dSdS)aCreates a new server with the given definition. The `job_name`, `task_index`, and `protocol` arguments are optional, and override any information provided in `server_or_cluster_def`. Args: server_or_cluster_def: A `tf.train.ServerDef` or `tf.train.ClusterDef` protocol buffer, or a `tf.train.ClusterSpec` object, describing the server to be created and/or the cluster of which it is a member. job_name: (Optional.) Specifies the name of the job of which the server is a member. Defaults to the value in `server_or_cluster_def`, if specified. task_index: (Optional.) Specifies the task index of the server in its job. Defaults to the value in `server_or_cluster_def`, if specified. Otherwise defaults to 0 if the server's job has only one task. protocol: (Optional.) Specifies the protocol to be used by the server. Acceptable values include `"grpc", "grpc+verbs"`. Defaults to the value in `server_or_cluster_def`, if specified. Otherwise defaults to `"grpc"`. config: (Options.) A `tf.compat.v1.ConfigProto` that specifies default configuration options for all sessions that run on this server. start: (Optional.) Boolean, indicating whether to start the server after creating it. Defaults to `True`. Raises: tf.errors.OpError: Or one of its subclasses if an error occurs while creating the TensorFlow server. N)r! _server_defc_api TF_NewServerSerializeToString_serverstart)selfrr rrrr)rrr __init__ks# zServer.__init__cCsRtdurtj}nt}zt|jWntyYn |y#Ynwd|_dSN)rUnimplementedError Exceptionr% TF_ServerStopr(AttributeError)r* exceptionrrr __del__s   zServer.__del__cCt|jdS)zStarts this server. Raises: tf.errors.OpError: Or one of its subclasses if an error occurs while starting the TensorFlow server. N)r%TF_ServerStartr(r*rrr r)sz Server.startcCr3)zBlocks until the server has shut down. This method currently blocks forever. Raises: tf.errors.OpError: Or one of its subclasses if an error occurs while joining the TensorFlow server. N)r% TF_ServerJoinr(r5rrr joins z Server.joincC|jS)zReturns the `tf.train.ServerDef` for this server. Returns: A `tf.train.ServerDef` protocol buffer that describes the configuration of this server. )r$r5rrr rszServer.server_defcCs t|jS)azReturns the target for a `tf.compat.v1.Session` to connect to this server. To create a `tf.compat.v1.Session` that connects to this server, use the following snippet: ```python server = tf.distribute.Server(...) with tf.compat.v1.Session(server.target): # ... ``` Returns: A string containing a session target for this server. )r%TF_ServerTargetr(r5rrr targets z Server.targetcCstddgid||dS)adCreates a new single-process cluster running on the local host. This method is a convenience wrapper for creating a `tf.distribute.Server` with a `tf.train.ServerDef` that specifies a single-process cluster containing a single task in a job called `"local"`. Args: config: (Options.) A `tf.compat.v1.ConfigProto` that specifies default configuration options for all sessions that run on this server. start: (Optional.) Boolean, indicating whether to start the server after creating it. Defaults to `True`. Returns: A local `tf.distribute.Server`. localhostz localhost:0r )rrr))r#)rr)rrr create_local_servers zServer.create_local_server)NNNNT)NT) __name__ __module__ __qualname____doc__r+r2r)r7propertyrr: staticmethodr<rrrr r#^s"  )   r#ztrain.ClusterSpecc@seZdZdZddZddZeZddZdd Zd d Z d d Z ddZ e ddZ ddZddZddZddZddZdS)raRepresents a cluster as a set of "tasks", organized into "jobs". A `tf.train.ClusterSpec` represents the set of processes that participate in a distributed TensorFlow computation. Every `tf.distribute.Server` is constructed in a particular cluster. To create a cluster with two jobs and five tasks, you specify the mapping from job names to lists of network addresses (typically hostname-port pairs). ```python cluster = tf.train.ClusterSpec({"worker": ["worker0.example.com:2222", "worker1.example.com:2222", "worker2.example.com:2222"], "ps": ["ps0.example.com:2222", "ps1.example.com:2222"]}) ``` Each job may also be specified as a sparse mapping from task indices to network addresses. This enables a server to be configured without needing to know the identity of (for example) all other worker tasks: ```python cluster = tf.train.ClusterSpec({"worker": {1: "worker1.example.com:2222"}, "ps": ["ps0.example.com:2222", "ps1.example.com:2222"]}) ``` cCs*t|trBi|_|D]/\}}t|ttfr!ddt|D}nt|tr0dd|D}ntd|||j|<q |dSt|t j re||_ i|_|j j D]}dd|j D|j|j<qRdSt|trt |_ |j |i|_|j j D]}dd|j D|j|j<q~dStd) aCreates a `ClusterSpec`. Args: cluster: A dictionary mapping one or more job names to (i) a list of network addresses, or (ii) a dictionary mapping integer task indices to network addresses; or a `tf.train.ClusterDef` protocol buffer. Raises: TypeError: If `cluster` is not a dictionary mapping strings to lists of strings, and not a `tf.train.ClusterDef` protobuf. cSi|]\}}||qSrr.0itaskrrr "sz(ClusterSpec.__init__..cSsi|] \}}t||qSr)intrDrrr rH$zMThe tasks for job %r must be a list or a dictionary from integers to strings.cSrCrrrErFtrrr rH. cSrCrrrKrrr rH6rMz}`cluster` must be a dictionary mapping one or more job names to lists of network addresses, or a `ClusterDef` protocol bufferN)rdict _cluster_specitemslisttuple enumerater_make_cluster_defr ClusterDef _cluster_defjobtasksnamerrr)r*r r rX job_tasksjob_defrrr r+s<         zClusterSpec.__init__cCs t|jSr,)boolrOr5rrr __bool__> zClusterSpec.__bool__cCs |j|kSr,rOr*otherrrr __eq__Dr^zClusterSpec.__eq__cCs |j|kSr,r_r`rrr __ne__Gr^zClusterSpec.__ne__cs0|fddtD}dd|dS)Ncs$g|]}t|dt|qS)z: )repr)rEk key_valuesrr Lsz(ClusterSpec.__repr__..z ClusterSpec({z, z}))as_dictsortedr7)r* string_itemsrrfr __repr__Js  zClusterSpec.__repr__cspi}jD]0}t|dkri|<qt|dt|kr)|<qfdd|D|<q|S)aReturns a dictionary from job names to their tasks. For each job, if the task index space is dense, the corresponding value will be a list of network addresses; otherwise it will be a dictionary mapping (sparse) task indices to the corresponding addresses. Returns: A dictionary mapping job names to lists or dictionaries describing the tasks in those jobs. rr csi|] }||qSr) task_address)rErFrWr*rr rHirJz'ClusterSpec.as_dict..)rrrmaxrZ)r*retrrrnr riQs   zClusterSpec.as_dictcCr8)zFReturns a `tf.train.ClusterDef` protocol buffer based on this cluster.)rVr5rrr rlszClusterSpec.as_cluster_defcCst|jS)zReturns a list of job names in this cluster. Returns: A list of strings, corresponding to the names of jobs in this cluster. )rQrOkeysr5rrr rpszClusterSpec.jobscCs0z |j|}Wt|Stytd|w)aReturns the number of tasks defined in the given job. Args: job_name: The string name of a job in this cluster. Returns: The number of tasks defined in the given job. Raises: ValueError: If `job_name` does not name a job in this cluster. No such job in cluster: %r)rOKeyErrorrrr*r rWrrr num_tasksys   zClusterSpec.num_taskscCs:z|j|}Wn tytd|wtt|S)aVReturns a list of valid task indices in the given job. Args: job_name: The string name of a job in this cluster. Returns: A list of valid task indices in the given job. Raises: ValueError: If `job_name` does not name a job in this cluster, or no task with index `task_index` is defined in that job. rr)rOrsrrQrjrqrtrrr rs    zClusterSpec.task_indicescCsTz|j|}Wn tytd|wz||WSty)td||fw)aReturns the address of the given task in the given job. Args: job_name: The string name of a job in this cluster. task_index: A non-negative integer. Returns: The address of the given task in the given job. Raises: ValueError: If `job_name` does not name a job in this cluster, or no task with index `task_index` is defined in that job. rrzNo task with index %r in job %r)rOrsr)r*r rrWrrr rms    zClusterSpec.task_addresscCsfz|j|}Wn tytd|wddtt|dD}|D]\}}|||<q(|S)aReturns a mapping from task ID to address in the given job. NOTE: For backwards compatibility, this method returns a list. If the given job was defined with a sparse set of task indices, the length of this list may not reflect the number of tasks defined in this job. Use the `tf.train.ClusterSpec.num_tasks` method to find the number of tasks defined in a particular job. Args: job_name: The string name of a job in this cluster. Returns: A list of task addresses, where the index in the list corresponds to the task index of each task. The list may contain `None` if the job was defined with a sparse set of task indices. Raises: ValueError: If `job_name` does not name a job in this cluster. rrcSsg|]}dqSr,r)rE_rrr rhz)ClusterSpec.job_tasks..r )rOrsrrangerorqrP)r*r rWrprFrGrrr rZs   zClusterSpec.job_tasksc Cst|_t|jD]G\}}zt|}Wn ty$td|w|jj }||_ t|D]\}}zt|}Wn tyLtd|w||j |<q4q dS)zCreates a `tf.train.ClusterDef` based on the given `cluster_spec`. Raises: TypeError: If `cluster_spec` is not a dictionary mapping strings to lists of strings. $Job name %r must be bytes or unicodez(Task address %r must be bytes or unicodeN) rrUrVrjrOrPras_bytesrrWaddrYrX)r*r rXr[rFrmrrr rTs(      zClusterSpec._make_cluster_defN)r=r>r?r@r+r] __nonzero__rbrcrlrirrArrurrmrZrTrrrr rs",  rz(config.experimental.ClusterDeviceFiltersc@s0eZdZdZddZddZddZdd Zd S) ClusterDeviceFiltersaaRepresent a collection of device filters for the remote workers in cluster. NOTE: this is an experimental API and subject to changes. Set device filters for selective jobs and tasks. For each remote worker, the device filters are a list of strings. When any filters are present, the remote worker will ignore all devices which do not match any of its filters. Each filter can be partially specified, e.g. "/job:ps", "/job:worker/replica:3", etc. Note that a device is always visible to the worker it is located on. For example, to set the device filters for a parameter server cluster: ```python cdf = tf.config.experimental.ClusterDeviceFilters() for i in range(num_workers): cdf.set_device_filters('worker', i, ['/job:ps']) for i in range(num_ps): cdf.set_device_filters('ps', i, ['/job:worker']) tf.config.experimental_connect_to_cluster(cluster_def, cluster_device_filters=cdf) ``` The device filters can be partically specified. For remote tasks that do not have device filters specified, all devices will be visible to them. cCsi|_d|_dSr,)_device_filters_cluster_device_filtersr5rrr r+ s zClusterDeviceFilters.__init__cCsFtdd|Ds J|j|idd|D|j||<d|_dS)z6Set the device filters for given job name and task id.css|]}t|tVqdSr,)rstrrEdfrrr sz:ClusterDeviceFilters.set_device_filters..cSsg|]}|qSrrrrrr rhrwz;ClusterDeviceFilters.set_device_filters..N)allr~ setdefaultr)r*r rdevice_filtersrrr set_device_filterss z'ClusterDeviceFilters.set_device_filterscCs|jr|jS||jS)z8Returns a serialized protobuf of cluster device filters.)r_make_cluster_device_filtersr5rrr _as_cluster_device_filterssz/ClusterDeviceFilters._as_cluster_device_filtersc Cst|_t|jD]P\}}zt|}Wn ty$td|w|jj }||_ t|D]'\}}|D] }zt|}Wn tyPtd|w|j |j |q:q4q dS)zCreates `ClusterDeviceFilters` proto based on the `_device_filters`. Raises: TypeError: If `_device_filters` is not a dictionary mapping strings to a map of task indices and device filters. ryz)Device filter %r must be bytes or unicodeN)rr}rrjr~rPrrzrrr{rYrXrappend)r*r rXjdfrFtask_device_filterstdfrrr r%s(      z1ClusterDeviceFilters._make_cluster_device_filtersN)r=r>r?r@r+rrrrrrr r}s   r}N)r@tensorflow.core.protobufrrrtensorflow.python.clientrr%tensorflow.python.frameworkrtensorflow.python.utilrr tensorflow.python.util.tf_exportr r!deprecated_endpointsr#rr}rrrr s&        C}