ijvddlZddlZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZejdk(rddlmZnejdk(rddl m!Znlejdk(rddl"m#ZnQejdk(rddl$m%Zn6ejdk(rddl&m'Zne(dejde ddgGddeej>e Z)e dd#d Z*d!Z+d"Z,y)$N)Callable)backend)utils) keras_export)Layer)map_saveable_variables) awq_quantize) gptq_quantize)should_quantize_layer) saving_api)trainer) summary_utils)traceback_utils tensorflow)TensorFlowTrainerjax) JAXTrainertorch) TorchTrainernumpy) NumpyTraineropenvino)OpenVINOTrainerz Backend 'z#' must implement the Trainer class.z keras.Modelzkeras.models.ModelceZdZdZfdZdZdZedZejdZe jddZ e j ddZ e jdd Ze jdd Ze jdd Zdd Zdd ZdZdZdZ ddZeddZdZd dZdZdZdZdZxZS)!ModelaFA model grouping layers into an object with training/inference features. There are three ways to instantiate a `Model`: ## With the "Functional API" You start from `Input`, you chain layer calls to specify the model's forward pass, and finally, you create your model from inputs and outputs: ```python inputs = keras.Input(shape=(37,)) x = keras.layers.Dense(32, activation="relu")(inputs) outputs = keras.layers.Dense(5, activation="softmax")(x) model = keras.Model(inputs=inputs, outputs=outputs) ``` Note: Only dicts, lists, and tuples of input tensors are supported. Nested inputs are not supported (e.g. lists of list or dicts of dict). A new Functional API model can also be created by using the intermediate tensors. This enables you to quickly extract sub-components of the model. Example: ```python inputs = keras.Input(shape=(None, None, 3)) processed = keras.layers.RandomCrop(width=128, height=128)(inputs) conv = keras.layers.Conv2D(filters=32, kernel_size=3)(processed) pooling = keras.layers.GlobalAveragePooling2D()(conv) feature = keras.layers.Dense(10)(pooling) full_model = keras.Model(inputs, feature) backbone = keras.Model(processed, conv) activations = keras.Model(conv, feature) ``` Note that the `backbone` and `activations` models are not created with `keras.Input` objects, but with the tensors that originate from `keras.Input` objects. Under the hood, the layers and weights will be shared across these models, so that user can train the `full_model`, and use `backbone` or `activations` to do feature extraction. The inputs and outputs of the model can be nested structures of tensors as well, and the created models are standard Functional API models that support all the existing APIs. ## By subclassing the `Model` class In that case, you should define your layers in `__init__()` and you should implement the model's forward pass in `call()`. ```python class MyModel(keras.Model): def __init__(self): super().__init__() self.dense1 = keras.layers.Dense(32, activation="relu") self.dense2 = keras.layers.Dense(5, activation="softmax") def call(self, inputs): x = self.dense1(inputs) return self.dense2(x) model = MyModel() ``` If you subclass `Model`, you can optionally have a `training` argument (boolean) in `call()`, which you can use to specify a different behavior in training and inference: ```python class MyModel(keras.Model): def __init__(self): super().__init__() self.dense1 = keras.layers.Dense(32, activation="relu") self.dense2 = keras.layers.Dense(5, activation="softmax") self.dropout = keras.layers.Dropout(0.5) def call(self, inputs, training=False): x = self.dense1(inputs) x = self.dropout(x, training=training) return self.dense2(x) model = MyModel() ``` Once the model is created, you can config the model with losses and metrics with `model.compile()`, train the model with `model.fit()`, or use the model to do prediction with `model.predict()`. ## With the `Sequential` class In addition, `keras.Sequential` is a special case of model where the model is purely a stack of single-input, single-output layers. ```python model = keras.Sequential([ keras.Input(shape=(None, None, 3)), keras.layers.Conv2D(filters=32, kernel_size=3), ]) ``` ct||r%|tk(rddlm}|j|g|i|St j |t||S)Nr Functional)functional_init_argumentsrkeras.src.models.functionalr__new__typingcastsuper)clsargskwargsr __class__s k/var/www/html/emotional.easysim.app/public_html/venv/lib/python3.12/site-packages/keras/src/models/model.pyr!z Model.__new__sM $T6 2se| >%:%%jB4B6B B{{3 455ctj|ddlm}t ||r6t |j |jj|g|i|ytj|g|i|y)Nr functional) Trainer__init__keras.src.modelsr-rinject_functional_model_classr(rr)selfr&r'r-s r)r/zModel.__init__sa/ %T6 2 )$.. 9 *J ! ! * *4 A$ A& A NN4 1$ 1& 1r*cHtd|jjd)NzModel z- does not have a `call()` method implemented.)NotImplementedErrorr(__name__)r2r&r's r)callz Model.calls+!T^^,,-." "  r*c:t|jddS)NF) include_self recursive)list_flatten_layers)r2s r)layersz Model.layerssD((eu(MNNr*ctd)NzU`Model.layers` attribute is reserved and should not be used. Please use another name.)AttributeError)r2_s r)r<z Model.layerss '  r*c ||td|d|d|Lt|j|kr%td|dt|jd|j|S|P|jD]}|j|k(s|cStd|dt d |jDdtd ) axRetrieves a layer based on either its name (unique) or index. If `name` and `index` are both provided, `index` will take precedence. Indices are based on order of horizontal graph traversal (bottom-up). Args: name: String, name of layer. index: Integer, index of layer. Returns: A layer instance. zz"Model.get_layer..s< <<=Q@  H  r*c <tj|||||||y)aYPrints a string summary of the network. Args: line_length: Total length of printed lines (e.g. set this to adapt the display to different terminal window sizes). positions: Relative or absolute positions of log elements in each line. If not provided, becomes `[0.3, 0.6, 0.70, 1.]`. Defaults to `None`. print_fn: Print function to use. By default, prints to `stdout`. If `stdout` doesn't work in your environment, change to `print`. It will be called on each line of the summary. You can set it to a custom function in order to capture the string summary. expand_nested: Whether to expand the nested models. Defaults to `False`. show_trainable: Whether to show if a layer is trainable. Defaults to `False`. layer_range: a list or tuple of 2 strings, which is the starting layer name and ending layer name (both inclusive) indicating the range of layers to be printed in summary. It also accepts regex patterns instead of exact names. In this case, the start predicate will be the first element that matches `layer_range[0]` and the end predicate will be the last element that matches `layer_range[1]`. By default `None` considers all layers of the model. Raises: ValueError: if `summary()` is called before the model is built. ) line_length positionsprint_fn expand_nestedshow_trainable layer_rangeN)r print_summary)r2rMrNrOrPrQrRs r)summaryz Model.summarys(R ## #')# r*c 6tj||f||d|S)aSaves a model as a `.keras` file. Note that `model.save()` is an alias for `keras.saving.save_model()`. The saved `.keras` file contains: - The model's configuration (architecture) - The model's weights - The model's optimizer's state (if any) Thus models can be reinstantiated in the exact same state. Args: filepath: `str` or `pathlib.Path` object. The path where to save the model. Must end in `.keras` (unless saving the model as an unzipped directory via `zipped=False`). overwrite: Whether we should overwrite any existing model at the target location, or instead ask the user via an interactive prompt. zipped: Whether to save the model as a zipped `.keras` archive (default when saving locally), or as an unzipped directory (default when saving on the Hugging Face Hub). Example: ```python model = keras.Sequential( [ keras.layers.Dense(5, input_shape=(3,)), keras.layers.Softmax(), ], ) model.save("model.keras") loaded_model = keras.saving.load_model("model.keras") x = keras.random.uniform((10, 3)) assert np.allclose(model.predict(x), loaded_model.predict(x)) ``` ) overwritezipped)r save_model)r2filepathrVrWr's r)savez Model.saves/T$$ ( &/ BH  r*c4tj||||S)aU Saves all weights to a single file or sharded files. By default, the weights will be saved in a single `.weights.h5` file. If sharding is enabled (`max_shard_size` is not `None`), the weights will be saved in multiple files, each with a size at most `max_shard_size` (in GB). Additionally, a configuration file `.weights.json` will contain the metadata for the sharded files. The saved sharded files contain: - `*.weights.json`: The configuration file containing 'metadata' and 'weight_map'. - `*_xxxxxx.weights.h5`: The sharded files containing only the weights. Args: filepath: `str` or `pathlib.Path` object. Path where the weights will be saved. When sharding, the filepath must end in `.weights.json`. If `.weights.h5` is provided, it will be overridden. overwrite: Whether to overwrite any existing weights at the target location or instead ask the user via an interactive prompt. max_shard_size: `int` or `float`. Maximum size in GB for each sharded file. If `None`, no sharding will be done. Defaults to `None`. Example: ```python # Instantiate a EfficientNetV2L model with about 454MB of weights. model = keras.applications.EfficientNetV2L(weights=None) # Save the weights in a single file. model.save_weights("model.weights.h5") # Save the weights in sharded files. Use `max_shard_size=0.25` means # each sharded file will be at most ~250MB. model.save_weights("model.weights.json", max_shard_size=0.25) # Load the weights in a new model with the same architecture. loaded_model = keras.applications.EfficientNetV2L(weights=None) loaded_model.load_weights("model.weights.h5") x = keras.random.uniform((1, 480, 480, 3)) assert np.allclose(model.predict(x), loaded_model.predict(x)) # Load the sharded weights in a new model with the same architecture. loaded_model = keras.applications.EfficientNetV2L(weights=None) loaded_model.load_weights("model.weights.json") x = keras.random.uniform((1, 480, 480, 3)) assert np.allclose(model.predict(x), loaded_model.predict(x)) ``` )rVmax_shard_size)r save_weights)r2rYrVr\s r)r]zModel.save_weights?s!l&& (i  r*c 6tj||fd|i|y)aLoad the weights from a single file or sharded files. Weights are loaded based on the network's topology. This means the architecture should be the same as when the weights were saved. Note that layers that don't have weights are not taken into account in the topological ordering, so adding or removing layers is fine as long as they don't have weights. **Partial weight loading** If you have modified your model, for instance by adding a new layer (with weights) or by changing the shape of the weights of a layer, you can choose to ignore errors and continue loading by setting `skip_mismatch=True`. In this case any layer with mismatching weights will be skipped. A warning will be displayed for each skipped layer. **Sharding** When loading sharded weights, it is important to specify `filepath` that ends with `*.weights.json` which is used as the configuration file. Additionally, the sharded files `*_xxxxx.weights.h5` must be in the same directory as the configuration file. Args: filepath: `str` or `pathlib.Path` object. Path where the weights will be saved. When sharding, the filepath must end in `.weights.json`. skip_mismatch: Boolean, whether to skip loading of layers where there is a mismatch in the number of weights, or a mismatch in the shape of the weights. Example: ```python # Load the weights in a single file. model.load_weights("model.weights.h5") # Load the weights in sharded files. model.load_weights("model.weights.json") ``` skip_mismatchN)r load_weights)r2rYr_r's r)r`zModel.load_weightsys-V    (   r*c~y)a/Returns the quantization structure for the model. This method is intended to be overridden by model authors to provide topology information required for structure-aware quantization modes like 'gptq'. Args: mode: The quantization mode. Returns: A dictionary describing the topology, e.g.: `{'pre_block_layers': [list], 'sequential_blocks': [list]}` or `None` if the mode does not require structure or is not supported. `'pre_block_layers'` is a list of layers that the inputs should be passed through, before being passed to the sequential blocks. For example, inputs to an LLM must first be passed through an embedding layer, followed by the transformer. N)r2modes r) get_quantization_layer_structurez&Model.get_quantization_layer_structures ( r*c 6|jdd}|r%td|jjd||7t |t t ttfstdt|d}|jD]L}t||stt|jdk(s6 |j||| d}N|d vrW|j$} | |j'|} | td |d |d k(rt)|| |n|dk(rt+|| ||r)d|_d|_d|_|j2|fi|yy#t$r)}tj t |Yd}~d}~wt"$rYwxYw)a Quantize the weights of the model. Note that the model must be built first before calling this method. `quantize` will recursively call `quantize(...)` in all layers and will be skipped if the layer doesn't implement the function. This method can be called by passing a `mode` string, which uses the default configuration for that mode. Alternatively, a `config` object can be passed to customize the behavior of the quantization (e.g. to use specific quantizers for weights or activations). Args: mode: The mode of the quantization. Supported modes are: `"int8"`, `"int4"`, `"float8"`, `"gptq"`. This is optional if `config` is provided. config: The configuration object specifying additional quantization options. This argument allows to configure the weight and activation quantizers. be an instance of `keras.quantizers.QuantizationConfig`. filters: Optional filters to apply to the quantization. Can be a regex string, a list of regex strings, or a callable. Only the layers which match the filter conditions will be quantized. **kwargs: Additional keyword arguments. Example: Quantize a model to int8 with default configuration: ```python # Build the model model = keras.Sequential([ keras.Input(shape=(10,)), keras.layers.Dense(10), ]) model.build((None, 10)) # Quantize with default int8 config model.quantize("int8") ``` Quantize a model to int8 with a custom configuration: ```python from keras.quantizers import Int8QuantizationConfig from keras.quantizers import AbsMaxQuantizer # Build the model model = keras.Sequential([ keras.Input(shape=(10,)), keras.layers.Dense(10), ]) model.build((None, 10)) # Create a custom config config = Int8QuantizationConfig( weight_quantizer=AbsMaxQuantizer( axis=0, value_range=(-127, 127) ), activation_quantizer=AbsMaxQuantizer( axis=-1, value_range=(-127, 127) ), ) # Quantize with custom config model.quantize(config=config) ``` type_checkTz)Unrecognized keyword arguments passed to z: NzaThe `filters` argument must be a regex string, a list of regex strings, or a callable. Received: F)rfconfig)gptqawqz For mode=z, a valid quantization structure must be provided either via `config.quantization_layer_structure` or by overriding `model.get_quantization_layer_structure(mode)`. The structure should be a dictionary with keys 'pre_block_layers' and 'sequential_blocks'.ri)filtersrj)poprHr(r5 isinstancestrrr:tupletyper;r rIquantizer4warningswarnr>quantization_layer_structurerdr r train_function test_functionpredict_function_post_quantize) r2rcrhrkr'rfgraph_modifiedrFe structures r)rqzModel.quantizesNZZ d3 !^^445RxA   gXtU'CD ?G}o' ))+ E(84--/01Q6NN4JvNN%)N  ? ";;I  AA$G    4'"BBv~fiAVY@ "&D !%D $(D ! D   / / =+*MM#a&))%s<E F$F FFc ~tjdk(r&|jD]}|jyy)Nr)rr;_track_variables)r2rcr'rFs r)rxzModel._post_quantizeFs< ??  '--/ )&&( ) (r*c|syd}d|vrStj|jr|j|d}n |j|dd}||_nZd|vrVtj|jr|j |d}n |jd i|dd}|d|_|s&t jd|jddyy#YxYw#Y>xYw) NF input_shapeT shapes_dictzModel 'a' had a build config, but the model cannot be built automatically in `build_from_config(config)`. You should implement `def build_from_config(self, config)`, and you might also want to implement the method that generates the config at saving time, `def get_build_config(self)`. The method `build_from_config()` is meant to create the state of the model (i.e. its variables) upon deserialization.) stacklevelrb) r is_defaultbuild _build_by_run_for_single_pos_arg_build_shapes_dict_build_by_run_for_kwargsrrrsrD)r2rhstatuss r)build_from_configzModel.build_from_configNs  F " +>>=)JJvm45!F'-D # f $ +66vm7LMDJJ7 !67!F'-]&;D # MM$)) %( ( !sC C' C$'C+c \ddlm}|j|}tj|fi|S)adReturns a JSON string containing the network configuration. To load a network from a JSON save file, use `keras.models.model_from_json(json_string, custom_objects={...})`. Args: **kwargs: Additional keyword arguments to be passed to `json.dumps()`. Returns: A JSON string. rserialization_lib)keras.src.savingrserialize_keras_objectjsondumps)r2r'r model_configs r)to_jsonz Model.to_json|s+ 7(??E zz,1&11r*c ddlm}ddlm}ddlm}ddlm} ddlm} d} || vrt d|d t| d |d k(r!tjd vr t d |dk(r"tjdk7r t d|dk(r| |||fd|i|y|dk(r||||fd|i|y|dk(r||||fd|i|y|d k(r|||f||d|y|dk(r| ||f||d|yy)a Export the model as an artifact for inference. Args: filepath: `str` or `pathlib.Path` object. The path to save the artifact. format: `str`. The export format. Supported values: `"tf_saved_model"`, `"onnx"`, `"openvino"`, `"litert"`, and `"torch"`. Defaults to `"tf_saved_model"`. 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`. Note: With `format="litert"` and the PyTorch backend, dynamic input shapes are not supported. Any dynamic dimensions (i.e., `None` in input shapes) will be automatically replaced with `1` during export, which may cause runtime failures for other shapes. You must explicitly pass a fixed static `input_signature` matching your maximum runtime shape. **kwargs: Additional keyword arguments. - `is_static`: Optional `bool`. Specific to the JAX backend and `format="tf_saved_model"`. Indicates whether `fn` is static. Set to `False` if `fn` involves state updates (e.g., RNG seeds and counters). - `jax2tf_kwargs`: Optional `dict`. Specific to the JAX backend and `format="tf_saved_model"`. Arguments for `jax2tf.convert`. See the documentation for [`jax2tf.convert`]( https://github.com/google/jax/blob/main/jax/experimental/jax2tf/README.md). If `native_serialization` and `polymorphic_shapes` are not provided, they will be automatically computed. - `opset_version`: Optional `int`. Specific to `format="onnx"`. An integer value that specifies the ONNX opset version. - LiteRT-specific options: Optional keyword arguments specific to `format="litert"`. These are passed directly to the TensorFlow Lite converter on the TensorFlow backend and include options like `optimizations`, `representative_dataset`, `experimental_new_quantizer`, `allow_custom_ops`, `enable_select_tf_ops`, etc. On the PyTorch backend, LiteRT export accepts `optimizations` plus the installed `litert_torch.convert()` keyword arguments such as `strict_export`, `dynamic_shapes` (note that standard ops do not support dynamic shapes, as noted below), `lightweight_conversion`, `enable_x64`, `runtime_constant_folding`, and `quant_config`. - PyTorch export options: Optional keyword arguments specific to `format="torch"`. These are passed directly to `torch.export.export` and include `strict`, `dynamic_shapes`, `prefer_deferred_runtime_asserts_over_guards`, and `preserve_module_call_signature`. **Note on LiteRT (TFLite) Export with PyTorch Backend:** With the PyTorch backend, LiteRT export (`format="litert"`) does not support dynamic input shapes. If no static signature is provided, any dynamic dimensions (represented as `None`) are automatically replaced with `1` during export. This can lead to runtime failures for other shapes. You must explicitly specify a fixed static `input_signature` (matching your maximum runtime dimensions) and pad your inputs to this static shape at runtime. **Note:** This feature is currently supported only with TensorFlow, JAX and Torch backends. **Note:** Be aware that the exported artifact may contain information from the local file system when using `format="onnx"`, `verbose=True` and Torch backend. Examples: Here's how to export a TensorFlow SavedModel for inference. ```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) ``` Here's how to export an ONNX for inference. ```python # Export the model as a ONNX artifact model.export("path/to/location", format="onnx") # Load the artifact in a different process/environment ort_session = onnxruntime.InferenceSession("path/to/location") ort_inputs = { k.name: v for k, v in zip(ort_session.get_inputs(), input_data) } predictions = ort_session.run(None, ort_inputs) ``` Here's how to export a LiteRT (TFLite) for inference. ```python # Export the model as a LiteRT artifact model.export("path/to/location", format="litert") # Load the artifact in a different process/environment interpreter = tf.lite.Interpreter(model_path="path/to/location") interpreter.allocate_tensors() interpreter.set_tensor( interpreter.get_input_details()[0]['index'], input_data ) interpreter.invoke() output_data = interpreter.get_tensor( interpreter.get_output_details()[0]['index'] ) ``` Here's how to export a PyTorch ExportedProgram for inference. ```python # Export the model as a PyTorch ExportedProgram artifact model.export("path/to/model.pt2", format="torch") # Load the artifact in a different process/environment import torch loaded_program = torch.export.load("path/to/model.pt2") predictions = loaded_program.module()(input_tensor) ``` r) export_litert) export_onnx)export_openvino)export_saved_model) export_torch)tf_saved_modelonnxrlitertrzUnrecognized format=z. Supported formats are: rAr)rrz5LiteRT export requires TensorFlow or PyTorch backend.rz&Torch export requires PyTorch backend.rinput_signaturerr)verboserN) keras.src.exportrrrrrrHr:r) r2rYformatrrr'rrrrravailable_formatss r)exportz Model.exportsP 30471  * *&vh.G)*+1.  X '//"3< # G  W !2g!=EF F % %  !0     v   !0     z !  !0     x    /     w    /     r*c ddlm}gd}tfd|D}tj|j }tj|j j dd}||thvxs4|j dd|k(xs |jdk(xr|jdk(}|r|rddlm } | || S |diS#t$r&} td |d |jd d | d} ~ wwxYw)Nrr)rDr< input_layers output_layersc3&K|]}|v ywrCrb)rEkeyrhs r)rGz$Model.from_config..js# !C6M# srgr&r')functional_from_configcustom_objectszUnable to revive model from config. When overriding the `get_config()` method, make sure that the returned config contains all items used as arguments in the constructor to z, which is the default behavior. You can override this default behavior by defining a `from_config(cls, config)` class method to specify how to create an instance of z# from its config. Received config=z, Error encountered during deserialization: rb) r rallinspectgetfullargspecr/r&rvarargsvarkwr TypeErrorr5) r%rhrrfunctional_config_keysis_functional_configargspecfunctional_init_argsrevivable_as_functionalrrzs ` r) from_configzModel.from_config`s9:"  ## %;#  ((6&55j6I6IJOO B  J& & I||AB#77 I6)Ggmmx.G $; K)VN  ==  *+./ #||n-##)(+==>C A   sC C8!C33C8c6i}t||t|S)N)storevisited_saveables)rset)r2rs r)_get_variable_mapzModel._get_variable_mapst5CEJ r*ci}|j|j||d<|j|j||d<|j|jj||d<|j|j ||d<|S)a3 Retrieves tree-like structure of model variables. This method allows retrieval of different model variables (trainable, non-trainable, optimizer, and metrics). The variables are returned in a nested dictionary format, where the keys correspond to the variable names and the values are the nested representations of the variables. Returns: dict: A dictionary containing the nested representations of the requested variables. The keys are the variable names, and the values are the corresponding nested dictionaries. value_format: One of `"backend_tensor"`, `"numpy_array"`. The kind of array to return as the leaves of the nested state tree. Example: ```python model = keras.Sequential([ keras.Input(shape=(1,), name="my_input"), keras.layers.Dense(1, activation="sigmoid", name="my_dense"), ], name="my_sequential") model.compile(optimizer="adam", loss="mse", metrics=["mae"]) model.fit(np.array([[1.0]]), np.array([[1.0]])) state_tree = model.get_state_tree() ``` The `state_tree` dictionary returned looks like: ``` { 'metrics_variables': { 'loss': { 'count': ..., 'total': ..., }, 'mean_absolute_error': { 'count': ..., 'total': ..., } }, 'trainable_variables': { 'my_sequential': { 'my_dense': { 'bias': ..., 'kernel': ..., } } }, 'non_trainable_variables': {}, 'optimizer_variables': { 'adam': { 'iteration': ..., 'learning_rate': ..., 'my_sequential_my_dense_bias_momentum': ..., 'my_sequential_my_dense_bias_velocity': ..., 'my_sequential_my_dense_kernel_momentum': ..., 'my_sequential_my_dense_kernel_velocity': ..., } } } } ``` trainable_variablesnon_trainable_variablesoptimizer_variablesmetrics_variables)_create_nested_dictrr optimizer variablesr)r2 value_formatrs r)get_state_treezModel.get_state_treesB +/+C+C  $ $l, '(04/G/G  ( (,0 +,,0+C+C NN $ $l, '(*.)A)A  " "L* %&r*ci}|D]x}|j|vrtd|jd|dk(r|j||j<I|dk(r|j||j<ltd|i}|j D]8\}}|j d}|} |ddD]} | | vri| | <| | } || |d<:|S)Nz:The following variable path is found twice in the model: 'z'. `get_state_tree()` can only be called when all variable paths are unique. Make sure to give unique names to your layers (and other objects).backend_tensor numpy_arrayzkInvalid `value_format` argument. Expected one of {'numpy_array', 'backend_tensor'}. Received: value_format=/)pathrHvalueritemssplit) r2rr flat_dictv nested_dictrrparts current_dictparts r)rzModel._create_nested_dicts  Avv" x @@ //$%GG !&&!.$%GGI !&&! $$0>3 & $??, ,KD%JJsOE&Lcr  2|+)+L&+D1  2',Lr # ,r*c|jD]\}}|j|}|dk(r|j|j|9|dk(r|j|j|[|dk(rAt |dsm|j z|j|j j||dk(r7t |ds|js|j|j|td|y)aAssigns values to variables of the model. This method takes a dictionary of nested variable values, which represents the state tree of the model, and assigns them to the corresponding variables of the model. The dictionary keys represent the variable names (e.g., `'trainable_variables'`, `'optimizer_variables'`), and the values are nested dictionaries containing the variable paths and their corresponding values. Args: state_tree: A dictionary representing the state tree of the model. The keys are the variable names, and the values are nested dictionaries representing the variable paths and their values. rrrrNrzUnknown variable name: ) r_flatten_nested_dict_assign_variable_valuesrrhasattrrrrrH)r2 state_treekrpath_value_dicts r)set_state_treezModel.set_state_tree s$$& @DAq"77:O)),,,,o//,,00/++4-$..2L0000/))D"56..00..!#:1#!>??1 @r*c|jD]-\}}|D]#}|j|k(s|j|%/yrC)rrassign)r2rrrrvariables r)rzModel._assign_variable_values6sE*002 +KD%% +==D(OOE* + +r*c,idfd |S)Nc|jD]-\}}t|tr|||d%|||</y)Nr)rrmdict)rprefixrr_flattenrs r)rz,Model._flatten_nested_dict.._flatten?sQ*002 8 UeT*Uvhse1$5627I./  8r*)rb)r2rrrs @@r)rzModel._flatten_nested_dict<s  8 r*)NN)NNNFFN)TN)FrC)NNN)rNN)r) r5 __module__ __qualname____doc__r!r/r6propertyr<setterrfilter_tracebackrKrTrZr]r`rdrqrxrrr classmethodrrrrrrr __classcell__)r(s@r)rr&sHfP6 2 OO ]]  %%& && P%%0 &0 d%%+ &+ Z%%7 &7 r%%/ &/ b.B0H),\2*  Pd44l N`B'@R+ r*rzkeras.models.model_from_jsonc^ddlm}tj|}|j ||S)a_Parses a JSON model configuration string and returns a model instance. Example: >>> model = keras.Sequential([ ... keras.layers.Dense(5, input_shape=(3,)), ... keras.layers.Softmax()]) >>> config = model.to_json() >>> loaded_model = keras.models.model_from_json(config) Args: json_string: JSON string encoding a model configuration. custom_objects: Optional dictionary mapping names (strings) to custom classes or functions to be considered during deserialization. Returns: A Keras model instance (uncompiled). rrr)rrrloadsdeserialize_keras_object) json_stringrrrs r)model_from_jsonrJs2*3::k*L  5 5^ 6 r*cbt|dk(xs t|dk(xrd|vxs d|vxrd|vS)Nrrgoutputsinputs)rI)r&r's r)rrgsC Ta 8 IN 2yF2 8   69#6r*cddlm}|tur |jS|turtSt d|j D|_|j||S)z?Inject `Functional` into the hierarchy of this class if needed.rr,c32K|]}t|ywrC)r1)rEbases r)rGz0inject_functional_model_class..zs04%d+s)r0r-rrobjectro __bases__r!)r%r-s r)r1r1osV+ e|$$$ f} 8; CM KK Jr*rC)-rrr"rrcollections.abcr keras.srcrrkeras.src.api_exportrkeras.src.layers.layerr!keras.src.models.variable_mappingrkeras.src.quantizers.awq_corer keras.src.quantizers.gptq_corer keras.src.quantizers.utilsr rr keras.src.trainersr base_trainerkeras.src.utilsrr$keras.src.backend.tensorflow.trainerrr.keras.src.backend.jax.trainerrkeras.src.backend.torch.trainerrkeras.src.backend.numpy.trainerr"keras.src.backend.openvino.trainerr RuntimeErrorrrrr1rbr*r)r s $-(D68<'6)+7?? $W__%CW__'!GW__'!GW__*$M  OGOO%&&IJ  }234`G\))5`5`F!,-.8r*