2VhFddlZddlZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZej d k(rdd lmZnej d k(rddlmZnlej dk(rddlmZnQej dk(rddlmZn6ej dk(rddlmZne dej deddgGddeej.e Z!edddZ"dZ#dZ$y) N)backend)utils) keras_export)Layer)map_saveable_variables) 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 Zd Zd ZdZ ddZeddZdZddZdZdZdZdZxZS)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 F/home/dcms/DCMS/lib/python3.12/site-packages/keras/src/models/model.pyrz 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__)r.r"r#s r%callz Model.calls+!T^^,,-." "  r&c:t|jddS)NF) include_self recursive)list_flatten_layers)r.s r%layersz Model.layerssD((eu(MNNr&ctd)NzU`Model.layers` attribute is reserved and should not be used. Please use another name.)AttributeError)r._s r%r8z 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)r.rIrJrKrLrMrNs 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)r.filepathrRrSr#s r%savez Model.save s/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)) ``` )rRmax_shard_size)r save_weights)r.rUrRrXs r%rYzModel.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)r.rUr[r#s r%r\zModel.load_weightsus-V    (   r&c ddlm}|jdd}|r%td|jj d|||vrtd|d|d }|j D]@}t|j }t|d k(s+ |j|| d}B|rd |_d |_d |_y y #t$r(}tjt|Yd }~d }~wwxYw) aQuantize the weights of the model. Note that the model must be built first before calling this method. `quantize` will recursively call `quantize(mode)` in all layers and will be skipped if the layer doesn't implement the function. Args: mode: The mode of the quantization. Only 'int8' is supported at this time. r)QUANTIZATION_MODES type_checkTz)Unrecognized keyword arguments passed to z: z+Invalid quantization mode. Expected one of z. Received: mode=F)r_N)keras.src.dtype_policiesr^poprDr$r1r7r6rEquantizer0warningswarnstrtrain_function test_functionpredict_function) r.moder#r^r_ mode_changedrBlist_of_sublayerses r%rczModel.quantizes @ZZ d3 !^^445RxA  ) )##5"66GvO  ))+ *E $U%:%:%< = $%**NN4JN?#'L  * "&D !%D $(D !  +*MM#a&))*sC C4 C//C4c|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.) stacklevel) r is_defaultbuild _build_by_run_for_single_pos_arg_build_shapes_dict_build_by_run_for_kwargsrdrer@)r.configstatuss r%build_from_configzModel.build_from_configs  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.savingr~serialize_keras_objectjsondumps)r.r#r~ model_configs r%to_jsonz Model.to_jsons+ 7(??E zz,1&11r&c ddlm}ddlm}d}||vrtd|dt |d|dk(r||||fd |i|y |d k(r||||fd |i|y y ) 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"` and `"onnx"`. 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`. **kwargs: Additional keyword arguments: - Specific to the JAX backend and `format="tf_saved_model"`: - `is_static`: Optional `bool`. Indicates whether `fn` is static. Set to `False` if `fn` involves state updates (e.g., RNG seeds and counters). - `jax2tf_kwargs`: Optional `dict`. 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. **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) ``` r) export_onnx)export_saved_model)tf_saved_modelonnxzUnrecognized format=z. Supported formats are: r=rinput_signaturerN)keras.src.exportrrrDr6) r.rUformatverboserr#rravailable_formatss r%exportz Model.exportsL 176 * *&vh.G)*+1.  % %  !0     v   !0     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)r@r8 input_layers output_layersc3&K|]}|v ywr?rs)rAkeyrys r%rCz$Model.from_config..zs# !C6M# sr`r"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: rs) rrallinspectgetfullargspecr+r"rvarargsvarkwr TypeErrorr1) r!ryrrfunctional_config_keysis_functional_configargspecfunctional_init_argsrevivable_as_functionalrrms ` r% from_configzModel.from_configps9:"  ## %;#  ((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)r.rs 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)r. 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=/)pathrDvalueritemssplit) r.rr 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(r'|j|j j ||dk(r|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. rrrrzUnknown variable name: N) r_flatten_nested_dict_assign_variable_valuesrrrrrrD)r. state_treekrpath_value_dicts r%set_state_treezModel.set_state_trees$$& @DAq"77:O)),,,,o//,,00/++,,NN,,o)),,**O!#:1#!>??' @r&c|jD]-\}}|D]#}|j|k(s|j|%/yr?)rrassign)r.rrrrvariables r%rzModel._assign_variable_valuesAsE*002 +KD%% +==D(OOE* + +r&c,idfd |S)Nc|jD]-\}}t|tr|||zdz&|||z</y)Nr)r isinstancedict)rprefixrr_flattenrs r%rz,Model._flatten_nested_dict.._flattenJsJ*002 4 UeT*UFSL3$67.3Ifsl+  4r&)rs)r.rrrs @@r%rzModel._flatten_nested_dictGs  4 r&)NN)NNNFFN)TN)F)rNNr?)r)r1 __module__ __qualname____doc__rr+r2propertyr8setterr filter_tracebackrGrPrVrYr\rcr{rr classmethodrrrrrrr __classcell__)r$s@r%rr"s=fP6 2 OO ]]  %%& && P%%0 &0 d%%+ &+ Z%%7 &7 r%%/ &/ b&)P,\2*  _B44l N`B"@H+ 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). rr}r)rr~rloadsdeserialize_keras_object) json_stringrr~rs r%model_from_jsonrUs2*3::k*L  5 5^ 6 r&cbt|dk(xs t|dk(xrd|vxs d|vxrd|vS)Nrqr`outputsinputs)rE)r"r#s r%rrrsC 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|ywr?)r-)rAbases r%rCz0inject_functional_model_class..s04%d+s)r,r)rrobjecttuple __bases__r)r!r)s r%r-r-zsV+ e|$$$ f} 8; CM KK Jr&r?)%rrrrd keras.srcrrkeras.src.api_exportrkeras.src.layers.layerr!keras.src.models.variable_mappingrrrkeras.src.trainersr base_trainerkeras.src.utilsr r $keras.src.backend.tensorflow.trainerr r*keras.src.backend.jax.trainerrkeras.src.backend.torch.trainerrkeras.src.backend.numpy.trainerr"keras.src.backend.openvino.trainerr RuntimeErrorrrrr-rsr&r%rs -(D'6)+7?? $W__%CW__'!GW__'!GW__*$M  OGOO%&&IJ  }234o G\))5o 5o d,-.8r&