&VfX ddlZddlZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z ddl mZddlmZdd lmZdd lmZejd krdd lmZnjejd krddlmZnPejdkrddlmZn6ejdkrddlmZnedejdeddgGddeeje ZedddZ dZ!dZ"dS)N)backend)utils) keras_export)Layer)map_saveable_variables) saving_api)trainer) summary_utils)traceback_utils tensorflow)TensorFlowTrainerjax) JAXTrainertorch) TorchTrainernumpy) NumpyTrainerz Backend 'z#' must implement the Trainer class.z keras.Modelzkeras.models.ModelcReZdZdZfdZdZdZedZej dZe j ddZ e j dd Z e j dd Ze j dd Ze j ddZdZdZdZddZeddZdZxZS)ModelaEA 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|tkrddlm}|j|i|St jtt|SNr functional) functional_init_argumentsrkeras.src.modelsr Functionaltypingcastsuper__new__)clsargskwargsr __class__s S/var/www/html/software/conda/lib/python3.11/site-packages/keras/src/models/model.pyr z Model.__new__si $T6 2 2 :se|| 3 3 3 3 3 3(:($9&99 9{5%''//#"6"6777ctj|ddlm}t ||r,t |j|jj|g|Ri|dStj|g|Ri|dSr) Trainer__init__rrrinject_functional_model_classr$rr)selfr"r#rs r%r)zModel.__init__s////// %T6 2 2 2 )$. 9 9 9 *J ! *4 A$ A A A& A A A A A N4 1$ 1 1 1& 1 1 1 1 1r&c<td|jjd)NzModel z- does not have a `call()` method implemented.)NotImplementedErrorr$__name__)r+r"r#s r%callz Model.calls/! "T^, " " "   r&cJt|ddS)NF) include_self recursive)list_flatten_layers)r+s r%layersz Model.layerss#D((eu(MMNNNr&c td)NzU`Model.layers` attribute is reserved and should not be used. Please use another name.)AttributeError)r+_s r%r5z Model.layerss '   r&Nc ||td|d|d|Mt|j|kr(td|dt|jd|j|S|K|jD]}|j|kr|cStd|d t 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. Nzz"Model.get_layer..s$<P # #')#      r&Tc *tj|||fi|S)aSaves a model as a `.keras` file. Args: filepath: `str` or `pathlib.Path` object. Path where to save the model. Must end in `.keras`. overwrite: Whether we should overwrite any existing model at the target location, or instead ask the user via an interactive prompt. save_format: The `save_format` argument is deprecated in Keras 3. Format to use, as a string. Only the `"keras"` format is supported at this time. 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)) ``` 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. )r save_model)r+filepath overwriter#s r%savez Model.save s"N$T8YII&IIIr&c0tj|||S)axSaves all layer weights to a `.weights.h5` file. Args: filepath: `str` or `pathlib.Path` object. Path where to save the model. Must end in `.weights.h5`. overwrite: Whether we should overwrite any existing model at the target location, or instead ask the user via an interactive prompt. )rQ)r save_weights)r+rPrQs r%rTzModel.save_weights3s&tXKKKKr&c 0tj||fd|i|dS)aLoad weights from a file saved via `save_weights()`. 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. Args: filepath: String, path to the weights file to load. It can either be a `.weights.h5` file or a legacy `.h5` weights file. 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. skip_mismatchN)r load_weights)r+rPrVr#s r%rWzModel.load_weights@s=6  (  *7 ;A     r&cddlm}|jstd||vrtd|d|d}|D]}t |}t |dkrQ ||d}O#t$r+}tj t|Yd }~d }~wwxYw|rd |_ d |_ d |_d Sd S) 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_MODESz:The model must be built first before calling `quantize()`.z+Invalid quantization mode. Expected one of z. Received: mode=FTN)keras.src.dtype_policiesrYbuiltrAr4r3rBquantizer-warningswarnstrtrain_function test_functionpredict_function)r+moderY mode_changedr?list_of_sublayerses r%r]zModel.quantize_sc @?????z L  ) ) )O#5OOHLOO  ))++ * *E $U%:%:%<%< = = $%%***NN4(((#'LL****M#a&&))))))))* +  )"&D !%D $(D ! ! ! ) )sB C%!C  Cc|sdSd|vretj|jr||d}n( ||dd}n #d}YnxYw||_nfd|vrbtj|jr||d}n |jd i|dd}n #d}YnxYw|d|_|s!t jd|jdddSdS) N input_shapeTF 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_kwargsr^r_r=)r+configstatuss r%build_from_configzModel.build_from_configsb  F F " " ++ #>>=)#JJvm4555!FF#"FFF&,D # # f $ $ ++ #66vm7LMM#DJ77 !6777!FF#"FFF&,]&;D #  M ($) ( ( (        sAA#(B>>Cc \ddlm}||}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.savingrxserialize_keras_objectjsondumps)r+r#rx model_configs r%to_jsonz Model.to_jsonsA 766666(??EE z,11&111r&tf_saved_modelc>ddlm}|||dS)aCreate a TF SavedModel artifact for inference. **Note:** This can currently only be used with the TensorFlow or JAX backends. 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. TF-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. Path where to save the artifact. Example: ```python # Create the artifact model.export("path/to/location") # Later, 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. r) export_libN)keras.src.exportr export_model)r+rPformatrs r%exportz Model.exports3D 0/////h/////r&c ddlm}gd}tfd|D}tj|j}tj|jjdd}||thvp(|jdd|kp|jdko |j dk}|r|rddlm } | || S |diS#t$r%} td |d |j d d | d} ~ wwxYw)Nr)r)r=r5 input_layers output_layersc3 K|]}|vV dSr<rm)r>keyrss r%r@z$Model.from_config..s8# # !C6M# # # # # # r&rZr"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: rm) keras.src.models.functionalrallinspectgetfullargspecr)r"rvarargsvarkwr TypeErrorr.) r!rsrrfunctional_config_keysis_functional_configargspecfunctional_init_argsrevivable_as_functionalrrgs ` r% from_configzModel.from_configs::::::" " "  ## # # # %;# # #   (66&5j6IJJO BB  J& & I|ABB#77 I6)Ggmx.G  $;  K J J J J J))VN  3====     A+. A A #| A A$* A A>? A A    s3B;; C* C%%C*cFi}t||t|S)N)storevisited_saveables)rset)r+rs r%_get_variable_mapzModel._get_variable_map!s%t5CEEJJJJ r&)NN)NNNFFN)T)F)rr<)r. __module__ __qualname____doc__r r)r/propertyr5setterr filter_tracebackrDrMrRrTrWr]rur~r classmethodrr __classcell__)r$s@r%rr sffP88888 2 2 2   OOXO ]  ] %& & & &%& P%/ / / &%/ b%&J&J&J&%&JP% L L L&% L%   &% <$)$)$)L+++Z222$$0$0$0$0L444[4lr&rzkeras.models.model_from_jsoncdddlm}tj|}|||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). rrwr)ryrxr{loadsdeserialize_keras_object) json_stringrrxr}s r%model_from_jsonr'sG*322222:k**L  5 5^ 6  r&cft|dkpt|dkod|vpd|vod|vS)NrkrZoutputsinputs)rB)r"r#s r%rrDsG Ta 8 IIN 2yF2 8   69#6r&cddlm}|tkr|jS|tkrtSt d|jD|_|||S)z?Inject `Functional` into the hierarchy of this class if needed.rrc34K|]}t|VdSr<)r*)r>bases r%r@z0inject_functional_model_class..Ws<04%d++r&)rrrrobjecttuple __bases__r )r!rs r%r*r*Ls~++++++ e||$$ f}} 8; CM KK Jr&r<)#rr{rr^ keras.srcrrkeras.src.api_exportrkeras.src.layers.layerr!keras.src.models.variable_mappingrryrkeras.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 RuntimeErrorrrrr*rmr&r%rsZ ------((((((DDDDDD''''''666666))))))++++++7? $$W_%CCCCCCCW_'!!GGGGGGGW_'!!GGGGGGG ,JOGO%%JJJ   }2344CCCCCG\)5CC54CL,--.-8r&