&`iJ rddlZddlZddlZddlmZmZmZmZmZm Z m Z ddl Z ddl m Z mZddlmZddlmZerddlmZejeZedd e e d effd Zedd e e d efd e eeefe eege fffd ZdS)N) TYPE_CHECKINGAnyCallableDictOptionalTypeUnion)PlacementGroupFactoryresource_dict_to_pg_factory)_ParameterRegistry) PublicAPI Trainablebeta) stability trainablerc  ddlm}tr$tjr0t |s t dtdt tj j j jtd |D]\}}  |z|t%dd}t'| tjrG fdd }nB fd }|}t+d r j|_t+d r j|_||_|S) a]Wrapper for trainables to pass arbitrary large data objects. This wrapper function will store all passed parameters in the Ray object store and retrieve them when calling the function. It can thus be used to pass arbitrary data, even datasets, to Tune trainables. This can also be used as an alternative to ``functools.partial`` to pass default arguments to trainables. When used with the function API, the trainable function is called with the passed parameters as keyword arguments. When used with the class API, the ``Trainable.setup()`` method is called with the respective kwargs. If the data already exists in the object store (are instances of ObjectRef), using ``tune.with_parameters()`` is not necessary. You can instead pass the object refs to the training function via the ``config`` or use Python partials. Args: trainable: Trainable to wrap. **kwargs: parameters to store in object store. Function API example: .. code-block:: python from ray import tune def train_fn(config, data=None): for sample in data: loss = update_model(sample) tune.report(dict(loss=loss)) data = HugeDataset(download=True) tuner = Tuner( tune.with_parameters(train_fn, data=data), # ... ) tuner.fit() Class API example: .. code-block:: python from ray import tune class MyTrainable(tune.Trainable): def setup(self, config, data=None): self.data = data self.iter = iter(self.data) self.next_sample = next(self.iter) def step(self): loss = update_model(self.next_sample) try: self.next_sample = next(self.iter) except StopIteration: return {"loss": loss, done: True} return {"loss": loss} data = HugeDataset(download=True) tuner = Tuner( tune.with_parameters(MyTrainable, data=data), # ... ) rrzw`tune.with_parameters() only works with function trainables or classes that inherit from `tune.Trainable()`. Got type: .___name__tune_with_parametersc(eZdZfdZxZS)with_parameters.._Innerci}D]}|z||<t|j|fi|dSN)getsupersetup) selfconfig setup_kwargsk_Inner __class__keysparameter_registryprefixs k/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/ray/tune/trainable/util.pyrz%with_parameters.._Inner.setuptsa! IIA&8&<&.inner~sNI B B155fqjAA ! 9V11y11 1r) __mixins__ _resources)ray.tune.trainablercallableinspectisclass issubclass ValueErrortyper ray_privateworker_post_init_hooksappendflushstritemsputgetattrsetr%hasattrr0r1r) rkwargsrr"vtrainable_nametrainable_with_paramsr/r#r%r&r's ` @@@@r(with_parametersrIsL-,,,,, I    "" +5i+K+K  "I " " "   ,--L(//0B0HIIII ! ! !F ..1vz1----Y 4JKKN v{{}}  Dy!!D B B B B B B B B B BY B B B!' 2 2 2 2 2 2 2 2 !& 9l + + D/8/C ! , 9l + + D/8/C ! ,%3"  r) resourcescddlm}tr$tjr0t |s t dtdt|tr|nVt|trt|n1t|r|nt dt|tjsSttj rfd}|_|S _n@#t$r}t!d|d}~wwxYwGfd d }j|_|S) aWrapper for trainables to specify resource requests. This wrapper allows specification of resource requirements for a specific trainable. It will override potential existing resource requests (use with caution!). The main use case is to request resources for function trainables when used with the Tuner() API. Class trainables should usually just implement the ``default_resource_request()`` method. Args: trainable: Trainable to wrap. resources: Resource dict, placement group factory, or callable that takes in a config dict and returns a placement group factory. Example: .. code-block:: python from ray import tune from ray.tune.tuner import Tuner def train_fn(config): return len(ray.get_gpu_ids()) # Returns 2 tuner = Tuner( tune.with_resources(train_fn, resources={"gpu": 2}), # ... ) results = tuner.fit() rrzv`tune.with_resources() only works with function trainables or classes that inherit from `tune.Trainable()`. Got type: rz.Invalid resource type for `with_resources()`: c|Sr)r rs r( _trainablez"with_resources.._trainables y(((r)zCould not use `tune.with_resources()` on the supplied trainable. Wrap your trainable in a regular function before passing it to Ray Tune.NcPeZdZedeeefdeeffd Z dS))with_resources..ResourceTrainabler returncfttstr |SSr) isinstancer r3)clsr pgfs r(default_resource_requestzBwith_resources..ResourceTrainable.default_resource_requests8"#'<=='(3--'3v;;& r)N) rr*r+ classmethodrr?rrr rV)rUsr(ResourceTrainablerPs[  !#s(^ /0     [   r)rX)r2rr3r4r5r6r7r8rSr dictr types MethodTyper1AttributeError RuntimeErrorr)rrJrrNerXrUs` @r(with_resourcesr_sV-,,,,, I    "" +5i+K+K  "I " " "   )233   It $ $ ))44 )    NT)__ N N    ?9 % %& i!1 2 2  ) ) ) ) )%(J !  #&I                  &/%7"% sD D.D))D.)r4loggingrZtypingrrrrrrr r9#ray.tune.execution.placement_groupsr r ray.tune.registryr ray.util.annotationsr r2r getLoggerrloggerrIr?floatrYr_rMr)r(rhs LLLLLLLLLLLLLLLLLL 100000******-,,,,,,  8 $ $ Vz!uT+%6%@Az!z!z!z!z V`T+&01` S%Z$../ 1``````r)