o 2h o@s8dZddlmZddlmZddlmZddlmZddlmZddlm Z ddl m Z dd l m Zed kr?dd lmZn>ed krLdd lmZn1edkrYddlmZn$edkrfddlmZnedkrsddlmZn ededdZedGdddeZ d"ddZd#ddZd d!ZdS)$z9Library for exporting SavedModel for Keras models/layers.)backend)layers)tree) keras_export)get_input_signature)make_tf_tensor_spec)io_utils) tensorflowr )TFExportArchivejax)JaxExportArchivetorch)TorchExportArchivenumpy)NumpyExportArchiveopenvino)OpenvinoExportArchivez Backend 'z' must implement ExportArchive.servezkeras.export.ExportArchivecseZdZdZfddZeddZeddZedd Zd d Z dfd d Z fddZ ddZ dddZ ddZddZddZddZZS) ExportArchivea ExportArchive is used to write SavedModel artifacts (e.g. for inference). If you have a Keras model or layer that you want to export as SavedModel for serving (e.g. via TensorFlow-Serving), you can use `ExportArchive` to configure the different serving endpoints you need to make available, as well as their signatures. Simply instantiate an `ExportArchive`, use `track()` to register the layer(s) or model(s) to be used, then use the `add_endpoint()` method to register a new serving endpoint. When done, use the `write_out()` method to save the artifact. The resulting artifact is a SavedModel and can be reloaded via `tf.saved_model.load`. Examples: Here's how to export a model for inference. ```python export_archive = ExportArchive() export_archive.track(model) export_archive.add_endpoint( name="serve", fn=model.call, input_signature=[keras.InputSpec(shape=(None, 3), dtype="float32")], ) export_archive.write_out("path/to/location") # Elsewhere, we can reload the artifact and serve it. # The endpoint we added is available as a method: serving_model = tf.saved_model.load("path/to/location") outputs = serving_model.serve(inputs) ``` Here's how to export a model with one endpoint for inference and one endpoint for a training-mode forward pass (e.g. with dropout on). ```python export_archive = ExportArchive() export_archive.track(model) export_archive.add_endpoint( name="call_inference", fn=lambda x: model.call(x, training=False), input_signature=[keras.InputSpec(shape=(None, 3), dtype="float32")], ) export_archive.add_endpoint( name="call_training", fn=lambda x: model.call(x, training=True), input_signature=[keras.InputSpec(shape=(None, 3), dtype="float32")], ) export_archive.write_out("path/to/location") ``` **Note on resource tracking:** `ExportArchive` is able to automatically track all `keras.Variables` used by its endpoints, so most of the time calling `.track(model)` is not strictly required. However, if your model uses lookup layers such as `IntegerLookup`, `StringLookup`, or `TextVectorization`, it will need to be tracked explicitly via `.track(model)`. Explicit tracking is also required if you need to be able to access the properties `variables`, `trainable_variables`, or `non_trainable_variables` on the revived archive. cs\ttdvrtdg|_i|_tj|_tj j |_ g|j _ g|j _g|j _dS)N)r r r zK`ExportArchive` is only compatible with TensorFlow, JAX and Torch backends.)super__init__rNotImplementedError_endpoint_names_endpoint_signaturestf __version__tensorflow_version __internal__tracking AutoTrackable _tf_trackable variablestrainable_variablesnon_trainable_variablesself __class__W/var/www/html/chatgem/venv/lib/python3.10/site-packages/keras/src/export/saved_model.pyrls   zExportArchive.__init__cC|jjSN)r r!r$r(r(r)r!}zExportArchive.variablescCr*r+)r r"r$r(r(r)r"r,z!ExportArchive.trainable_variablescCr*r+)r r#r$r(r(r)r#r,z%ExportArchive.non_trainable_variablescCst|tjr |js tdt|tjjjr#t |dsg|_ |j |t|tjr0| |dSt|tjjjsEtd|dt |ddS)a+Track the variables (of a layer or model) and other assets. By default, all variables used by an endpoint function are automatically tracked when you call `add_endpoint()`. However, non-variables assets such as lookup tables need to be tracked manually. Note that lookup tables used by built-in Keras layers (`TextVectorization`, `IntegerLookup`, `StringLookup`) are automatically tracked by `add_endpoint()`. Args: resource: A layer, model or a TensorFlow trackable resource. JThe layer provided has not yet been built. It must be built before export._trackedzoInvalid resource type. Expected a Keras `Layer` or `Model` or a TensorFlow `Trackable` object. Received object z of type 'z'. N) isinstancerLayerbuilt ValueErrorrrr Trackablehasattrr.append _track_layertype)r%resourcer(r(r)tracks&    zExportArchive.trackNc s||jvr td|dtdkr$d|vsd|vr$tdt|durRt|tjjjr?|s       zExportArchive.add_endpointc s||jvr td|dt|tjs td|dt|d|js'tdtdkr>d|vs5d |vr>td tt t |}t t d sZ| ||j||j|fi|Stj|||fi|}||j|<t|j|||j||S) aTrack the variables and register a new serving endpoint. This function combines the functionality of `track` and `add_endpoint`. It tracks the variables of the `resource` (either a layer or a model) and registers a serving endpoint using `resource.__call__`. Args: name: `str`. The name of the endpoint. resource: A trackable Keras resource, such as a layer or model. input_signature: Optional. Specifies the shape and dtype of `fn`. Can be a structure of `keras.InputSpec`, `tf.TensorSpec`, `backend.KerasTensor`, or backend tensor (see below for an example showing a `Functional` model with 2 input arguments). If not provided, `fn` must be a `tf.function` that has been called at least once. Defaults to `None`. **kwargs: Additional keyword arguments: - Specific to the JAX backend: - `is_static`: Optional `bool`. Indicates whether `fn` is static. Set to `False` if `fn` involves state updates (e.g., RNG seeds). - `jax2tf_kwargs`: Optional `dict`. Arguments for `jax2tf.convert`. See [`jax2tf.convert`]( https://github.com/google/jax/blob/main/jax/experimental/jax2tf/README.md). If `native_serialization` and `polymorphic_shapes` are not provided, they are automatically computed. r:r;z^Invalid resource type. Expected an instance of a Keras `Layer` or `Model`. Received: resource=z (of type )r-r r<r=r>track_and_add_endpoint)rr2r/rr0r7r1rrrDrr4BackendExportArchiver9rE__call__rrLrrCr r5)r%rFr8rHrIrJr&r(r)rLrsP       z$ExportArchive.track_and_add_endpointcCst|tttfstdt|dtdd|Ds+tdttdd|Dtdkr;t t |j |}t |j |t|dS) aRegister a set of variables to be retrieved after reloading. Arguments: name: The string name for the collection. variables: A tuple/list/set of `keras.Variable` instances. Example: ```python export_archive = ExportArchive() export_archive.track(model) # Register an endpoint export_archive.add_endpoint( name="serve", fn=model.call, input_signature=[keras.InputSpec(shape=(None, 3), dtype="float32")], ) # Save a variable collection export_archive.add_variable_collection( name="optimizer_variables", variables=model.optimizer.variables) export_archive.write_out("path/to/location") # Reload the object revived_object = tf.saved_model.load("path/to/location") # Retrieve the variables optimizer_variables = revived_object.optimizer_variables ``` zNExpected `variables` to be a list/tuple/set. Received instead object of type 'z'.css"|] }t|tjtjfVqdSr+)r/rVariabler.0vr(r(r) s z8ExportArchive.add_variable_collection..zgExpected all elements in `variables` to be `tf.Variable` instances. Found instead the following types: css|]}t|VqdSr+)r7rPr(r(r)rSsr N)r/listtuplesetr2r7allrrflattenrD_convert_to_tf_variablerCr )r%rFr!r(r(r)add_variable_collections&  z%ExportArchive.add_variable_collectionTcsjstdi}jD] }|||<qdjvr)jd|d<tjjj|||drQdfddjD}t d|d |d Sd S) a"Write the corresponding SavedModel to disk. Arguments: filepath: `str` or `pathlib.Path` object. Path where to save the artifact. options: `tf.saved_model.SaveOptions` object that specifies SavedModel saving options. verbose: whether to print all the variables of an exported SavedModel. **Note on TF-Serving**: all endpoints registered via `add_endpoint()` are made visible for TF-Serving in the SavedModel artifact. In addition, the first endpoint registered is made visible under the alias `"serving_default"` (unless an endpoint with the name `"serving_default"` was already registered manually), since TF-Serving requires this endpoint to be set. z4No endpoints have been set yet. Call add_endpoint().serving_defaultr)options signaturesz c3s&|]}ttj||dVqdS)verboseN)_print_signaturegetattrr rQrFr%r_r(r)rSs z*ExportArchive.write_out..zSaved artifact at 'z+'. The following endpoints are available: N) rr2_filter_and_track_resources_get_concrete_fnr saved_modelsaver joinr print_msg)r%filepathr\r_r]rF endpointsr(rcr) write_outs8  zExportArchive.write_outcCs@t|tjstd|dt|dtj|j|j|j|j dS)NzL`backend_variable` must be a `backend.Variable`. Recevied: backend_variable=z of type (rK)dtype trainablerF) r/rrO TypeErrorr7rvaluermrnrF)r%backend_variabler(r(r)rYs z%ExportArchive._convert_to_tf_variablecCs8||jvr t|j|St|j|d}t|dS)z&Workaround for some SavedModel quirks.rfr)rrar _trackable_childrenrTvalues)r%endpointtracesr(r(r)re,s   zExportArchive._get_concrete_fncsfddjD}t|S)Ncg|]}|qSr(rerbr$r(r) 7zBExportArchive._get_variables_used_by_endpoints..)r_list_variables_used_by_fns)r%fnsr(r$r) _get_variables_used_by_endpoints6sz.ExportArchive._get_variables_used_by_endpointscsfddjD}t|\}}t||j_gj_ddlm}tdrFj D]}t j | }|D]}t||rDjj|q6q*dSdS)zBTrack resources used by endpoints / referenced in `track()` calls.crvr(rwrbr$r(r)rx=ryz=ExportArchive._filter_and_track_resources..r)TrackableResourcer.N)rrzrTr _all_variables _misc_assets#tensorflow.saved_model.experimentalr}r4r.rtrain TrackableView descendantsr/r5)r%r{tvsntvsr}rootr trackabler(r$r)rd:s     z)ExportArchive._filter_and_track_resourcesr+)NT)__name__ __module__ __qualname____doc__rpropertyr!r"r#r9rErLrZrlrYrer|rd __classcell__r(r(r&r)r)s& A   $ FD 26 rNcKsJ|durd}t}|durt|}|jt||fi||j||ddS)a Export the model as a TensorFlow SavedModel artifact for inference. This method lets you export a model to a lightweight SavedModel artifact that contains the model's forward pass only (its `call()` method) and can be served via e.g. TensorFlow Serving. The forward pass is registered under the name `serve()` (see example below). The original code of the model (including any custom layers you may have used) is *no longer* necessary to reload the artifact -- it is entirely standalone. Args: filepath: `str` or `pathlib.Path` object. The path to save the artifact. verbose: `bool`. Whether to print a message during export. Defaults to `None`, which uses the default value set by different backends and formats. input_signature: Optional. Specifies the shape and dtype of the model inputs. Can be a structure of `keras.InputSpec`, `tf.TensorSpec`, `backend.KerasTensor`, or backend tensor. If not provided, it will be automatically computed. Defaults to `None`. **kwargs: Additional keyword arguments: - Specific to the JAX backend: - `is_static`: Optional `bool`. Indicates whether `fn` is static. Set to `False` if `fn` involves state updates (e.g., RNG seeds). - `jax2tf_kwargs`: Optional `dict`. Arguments for `jax2tf.convert`. See [`jax2tf.convert`]( https://github.com/google/jax/blob/main/jax/experimental/jax2tf/README.md). If `native_serialization` and `polymorphic_shapes` are not provided, they are automatically computed. **Note:** This feature is currently supported only with TensorFlow, JAX and Torch backends. Support for the Torch backend is experimental. **Note:** The dynamic shape feature is not yet supported with Torch backend. As a result, you must fully define the shapes of the inputs using `input_signature`. If `input_signature` is not provided, all instances of `None` (such as the batch size) will be replaced with `1`. Example: ```python # Export the model as a TensorFlow SavedModel artifact model.export("path/to/location", format="tf_saved_model") # Load the artifact in a different process/environment reloaded_artifact = tf.saved_model.load("path/to/location") predictions = reloaded_artifact.serve(input_data) ``` If you would like to customize your serving endpoints, you can use the lower-level `keras.export.ExportArchive` class. The `export()` method relies on `ExportArchive` internally. NTr^)rrrLDEFAULT_ENDPOINT_NAMErl)modelrjr_rHrIexport_archiver(r(r)export_saved_modelNs9rTcCsJ|d}|j|d}|d}d|dg|dd}d|}|S)Nrr^ z * Endpoint '')rBpretty_printed_signaturesplitrh)rGrFr_ concrete_fnpprinted_signaturelinesrtr(r(r)r`s    r`c Csg}g}t}t}|D]T}t|dr|j}nt|dr"|g}n|g}|D]8}|jD]}t||vr@|||t|q,|jD]}t||vr^t||vr^|||t|qDq'q ||fS)Nconcrete_functionsget_concrete_function) rVr4rrr"idr5addr!) r{r"r#trainable_variables_idsnon_trainable_variables_idsrGrrrRr(r(r)rzs2           rz)NN)T) r keras.srcrrrkeras.src.api_exportrkeras.src.export.export_utilsrrkeras.src.utilsrkeras.src.utils.module_utilsr r#keras.src.backend.tensorflow.exportr rMkeras.src.backend.jax.exportr keras.src.backend.torch.exportrkeras.src.backend.numpy.exportr!keras.src.backend.openvino.exportr RuntimeErrorrrrr`rzr(r(r(r)sB             ) E